192.168.1.100:1080

The problem was that pip doesn’t support SOCKS proxies out of the box. Normally, you’d install PySocks to enable that — but since pip itself wasn’t working, that wasn’t an option.

I used the ProxyMapService to expose the SOCKS5 proxy as a local HTTP proxy. Here’s the rule I configured:

{  "Listen": {    "Port": 10000,    "RejectHttpProxy": false  },  "Authentication": {    "Required": false,    "Verify": false,    "SetAuthentication": false  },  "ProxyServers": {    "Items": [      {        "Host": "192.168.1.100",        "Port": 1080,        "ProxyType": "Socks5"      }    ]  }}

After that, pip started working by pointing it to the local HTTP proxy:

pip install cython --proxy http://127.0.0.1:10000Collecting cython  Using cached cython-3.2.4-cp311-cp311-win_amd64.whl.metadata (7.7 kB)Using cached cython-3.2.4-cp311-cp311-win_amd64.whl (2.8 MB)Installing collected packages: cythonSuccessfully installed cython-3.2.4

🎉

Many modern proxy providers sell so-called sticky proxies (also known as session-based proxies). This is a very popular solution for scraping, automation, data collection, and working around anti-bot protections.

What is a sticky proxy?

A sticky proxy is a proxy server that “locks” one IP address to you for a certain amount of time (for example, 5 or 10 minutes) using a session. Usually, the session is defined via the username, for example:

user-session-ABC123-sessTime-10:password@proxy_host:proxy_port

While the session is active, you will access the internet from the same IP address. When the time expires or you change the session ID, you get a new IP.

Today, most large proxy providers (residential, mobile, ISP) work exactly this way: you connect to a single host and port, and IP rotation is controlled via parameters in the username.

The problem: not all software supports sticky proxies

Many applications (scraping software, old parsers, bots, automation tools):

• ❌ cannot work with proxies that require authentication
• ❌ cannot manage sessions
• ❌ expect just a list of IP:PORT, without username and password

Because of this, they cannot be directly connected to modern sticky proxy providers.

The solution: map local TCP ports through sticky proxies

The idea is very simple:

• We run a local service
• It opens a range of local ports
• Each local port:
  • automatically connects to the sticky proxy
  • uses its own separate session
• As a result:
  • 127.0.0.1:5001 → sticky proxy session AAA1
  • 127.0.0.1:5002 → sticky proxy session AAA2
  • 127.0.0.1:5003 → sticky proxy session AAA3
  • and so on

And your software just works with regular proxies without authentication:

127.0.0.1:5001127.0.0.1:5002127.0.0.1:5003

Ready-made solution: ProxyMapService

For this purpose, the following open-source project works perfectly:

👉 ProxyMapService
https://github.com/optinsoft/ProxyMapService

It can:

• map port ranges
• automatically manage sticky sessions
• work with HTTP / SOCKS proxies
• modify / generate username parameters

Configuration example

Here is an example config:

"ProxyMappings": [  {    "Listen": {      "PortRange": {        "Start": 10001,        "End": 10100      },      "RejectHttpProxy": false,      "StickyProxyLifetime": 10    },    "Authentication": {      "Required": false,      "Verify": false,      "SetAuthentication": false,      "RemoveAuthentication": false    },    "ProxyServers": {      "Items": [        {          "Host": "PROXY_IP",          "Port": PROXY_PORT,          "ProxyType": "Http",          "Username": "USERNAME",          "Password": "PASSWORD",          "UsernameParameters": [            {              "Name": "zone",              "Value": "custom"            },            {              "Name": "region",              "Value": "US"            },            {              "Name": "session",              "Value": "^[A-Za-z]{8}",              "SessionId": true            },            {              "Name": "sessTime",              "Value": "$sessTime",              "Default": "10",              "SessionTime": true            }          ]        }      ]    }  }]

⚠️ In this example you need to replace:

• PROXY_IP
• PROXY_PORT
• USERNAME
• PASSWORD

with the values provided by your proxy provider.

How does it work in practice?

• ProxyMapService opens local ports 10001–10100

• Each port:

  • automatically generates a new sticky session
  • keeps it for StickyProxyLifetime = 10 minutes

• You just set in your software:

127.0.0.1:10001127.0.0.1:10002127.0.0.1:10003...

Conclusion

If your software:

• doesn’t support proxy authentication
• doesn’t support sessions
• only works with IP:PORT lists

➡️ ProxyMapService solves this problem completely, allowing you to use modern sticky proxies without modifying your software.

Useful for:

• scraping software
• bots
• automation tools
• legacy tools
• and basically any software with poor proxy support

The Challenge: Managing Complex Usernames

Sometimes, proxy usernames need to encode more information than just the account identifier.

For example, a proxy might look like this:

http://user-zone-custom-region-US-session-1234567-sessionTime-5:1111@127.0.0.1:8888

Username part of the proxy is user-zone-custom-region-US-session-1234567-sessionTime-5.

While this format might be necessary for other parts of the system or for identification, it complicates the standard authentication process by requiring the system to ignore the extra parts (zone, region, session, etc.) and focus solely on the actual username.

The Solution: Introducing ParseUsernameParameters

To address this need for cleaner authentication, we’ve introduced a new configuration parameter called ParseUsernameParameters. This boolean parameter resides within the Authentication section of the appsettings.json file.

• Parameter Name: ParseUsernameParameters
• Allowed Values: true or false (default is false)

What Does This Parameter Do?

When set to true, the ProxyMapService will parse the username string during authentication. It splits the username using the hyphen (-) delimiter. Crucially, only the first segment (the part before the first hyphen) is used for the authentication check. The remaining segments are ignored.

How It Works (Example)

Let’s take a look at the authentication logic with ParseUsernameParameters=true:

1. Input Username (part of the proxy):

   "user-zone-custom-region-US-session-1234567-sessionTime-5"

2. Authentication Logic (with ParseUsernameParameters=true):

   • The username string user-zone-custom-region-US-session-1234567-sessionTime-5 is split using the - character.
   • The resulting parts are: ["user", "zone", "custom", "region", "US", "session", "1234567", "sessionTime", "5"]
   • Authentication Check: The system compares the first part, user, to the configured Username value (e.g., "user" from the example config). The rest of the parts are completely ignored for authentication.

Configuration Example (appsettings.json)

Here’s how you would enable this feature in your appsettings.json:

{  "Authentication": {    // ... other authentication settings ...    "Required": true,    "Verify": true,    "ParseUsernameParameters": true,    "Username": "user",  // This is the base username to compare against    "Password": "1111"    // Password  }}

We’re pleased to announce the release of Web Proxy Checker version 2.111 – our reliable tool for testing proxy server functionality now includes improved handling for CONNECT (HTTPS) proxies with non-standard authentication behavior.

Standard Proxy Authentication Flow

When connecting to a proxy requiring Basic Authentication, the expected protocol is:

1. Client (browser or our tool) connects without credentials
2. Proxy responds with “407 Proxy Authentication Required”
3. Client reconnects with the Proxy-Authorization HTTP header
4. Connection proceeds if credentials are valid

This standard flow is used by all major browsers (Chrome, Firefox, Edge) and has been Web Proxy Checker’s default behavior.

The Challenge: Non-Compliant Proxies

During testing, we identified proxies that don’t follow authentication standards. Instead of returning the proper 407 error, they immediately close connections when credentials are missing. This creates a compatibility issue where legitimate authentication attempts fail.

New Feature: “Connect Basic Authentication” Setting

Version 2.111 introduces a solution on the HTTP tab: the new “Connect Basic Authentication” option.

How it works:

• Disabled (Default): Standard behavior – waits for 407 response before sending credentials
• Enabled: Immediately includes Proxy-Authorization header in the first connection attempt
• Result: Compatibility with proxies that require immediate authentication

Usage Recommendations:

• Most users should keep this setting disabled (works with standard proxies)
• Enable only when encountering proxies that close connections without 407 responses
• Particularly useful for certain corporate or custom proxy setups

Quick Setup:

1. Launch Web Proxy Checker v2.111
2. Go to the HTTP tab
3. Find “Connect Basic Authentication” checkbox
4. Enable for problematic proxies, disable for standard ones

What This Means for You:

• ✓ Wider proxy compatibility
• ✓ No more failed connections with non-standard proxies
• ✓ Backward compatibility maintained
• ✓ Easy toggle between authentication modes

Upgrade Today

Download Web Proxy Checker v2.111 and experience improved compatibility with all your proxy servers!

1. Enabling Event Log Logging

To enable writing events to the Windows Event Log, you need to make a small change in your project’s configuration file — appsettings.json.

Add the EventLog section within the Logging block, specifying the desired minimum logging level. The example below sets the level to “Information”:

{  "Logging": {    "EventLog": {      "LogLevel": {        "Default": "Information"      }    }  }}

💡 Note: The Default level within the EventLog section determines the minimum level (Trace, Debug, Information, Warning, Error, Critical) at which messages will be written to the log.

2. Mandatory Step: Registering the Event Source (PowerShell)

Attention! For messages to be successfully displayed in the Event Log and for the system to correctly identify their source and formatting, it is necessary to register the event source with the name ProxyMapService beforehand.

Event source registration is only required once upon installation or update of the service.

Use PowerShell run as administrator and execute the following command. This command creates the necessary registry key:

New-EventLog -LogName Application -Source ProxyMapService

• New-EventLog: The cmdlet used to create a new event source.
• -LogName Application: Specifies that the source will write to the standard “Application” log.
• -Source ProxyMapService: Sets the source name, which must match the name used within the service code.

3. Viewing the Events

After configuring appsettings.json and registering the source, restart the ProxyMapService. All events at the Information level and above will now be available for viewing in the Windows Event Viewer under Windows Logs $\rightarrow$ Application.

Look for messages with the Source: ProxyMapService.

🔗 Source Code and Discussion: As always, you can find the latest version of the project on GitHub: https://github.com/optinsoft/ProxyMapService

tz_names = pytz.country_timezones.get(country.upper(), [])

When I needed similar functionality in Delphi, I was surprised to find that there wasn’t a readily available library to get IANA timezone names for countries.

After searching without success, I decided to create my own solution:

https://github.com/optinsoft/CountryTimezone

Here’s a practical example that demonstrates how to get a random timezone name and its UTC offset for a given country:

uses CountryTimezone, TZDB;type   TTimezoneAndOffset = record        name: String;        offset: Integer;   end;function GetRandomTimezoneAndOffset(country: String): TTimezoneAndOffset;var  LCTZDict: TCountryTimezoneDictionary;  LCTZList: TStringList;  tz: TBundledTimeZone;begin  LCTZDict := TCountryTimezoneDictionary.Create();  LCTZList := TStringList.Create;  try    LCTZDict.GetCountryTimezones(country, LCTZList);    Result.name := LCTZList[Random(LCTZList.Count)];    tz := TBundledTimeZone.GetTimeZone(Result.name);    Result.offset := Trunc(tz.UtcOffset.TotalMinutes);  finally    LCTZList.Free;    LCTZDict.Free;  end;end;

This function:

1. Creates a country timezone dictionary
2. Retrieves all timezone names for the specified country
3. Selects a random timezone from the list
4. Uses TZDB to get the UTC offset in minutes for that timezone

When working with JavaScript, there are times you might want to automatically rename variables or functions across your code — perhaps for obfuscation, code transformation, or refactoring. Doing this safely, without accidentally breaking your program, requires understanding how your code is structured — and that’s where the Abstract Syntax Tree (AST) comes in.

In this post, we’ll look at how to rename variable and function declarations using ASTs, with a simple utility renamedecl.

🌳 What Is an AST?

An Abstract Syntax Tree (AST) is a structured, tree-like representation of your source code.
Instead of dealing with raw text, you work with objects that represent program constructs like variables, functions, loops, and expressions.

For example, the code:

const x = 5;console.log(x);

can be represented (simplified) as:

{  type: "Program",  body: [    {      type: "VariableDeclaration",      declarations: [        {          type: "VariableDeclarator",          id: { type: "Identifier", name: "x" },          init: { type: "Literal", value: 5 }        }      ]    },    {      type: "ExpressionStatement",      expression: {        type: "CallExpression",        callee: {          object: { name: "console" },          property: { name: "log" }        },        arguments: [{ type: "Identifier", name: "x" }]      }    }  ]}

By working with this structure, you can programmatically modify parts of your code (e.g. change x to width) and then regenerate valid JavaScript source code.

🧩 Tools: Acorn, Escodegen

• Acorn — a fast, lightweight JavaScript parser. It converts JS source code into an AST.
• Escodegen — generates readable JavaScript code from an AST.

Scopes

Scopes — just like in real code, variables and functions in an AST exist within scopes (e.g., global, function, block). When renaming identifiers, you need to make sure you don’t accidentally rename a variable from an outer scope that has the same name.

🚀 Introducing renamedecl

renamedecl is the lightweight tool for renaming variables and functions in JS code based on an AST.

The function renameDeclarations(ast, rename, initscope?) walks through your AST, finds all declarations (variables, function names, parameters, etc.), and lets you rename them safely according to the rules you define.

It can be used in two main ways:

1. Automatic Renaming

You can rename every variable and function in a consistent way — for example, to obfuscate or anonymize code.

const acorn = require('acorn');const escodegen = require('escodegen');const { renameDeclarations } = require('renamedecl');const originalCode = `function add(x, y) {    const result = x + y;    return result;}`;const ast = acorn.parse(originalCode, {    ecmaVersion: 2020,    sourceType: 'script'});// Rename all identifiers sequentiallyrenameDeclarations(    ast,    (id, scope) => `v${++scope.varNum}`,    scope => { scope.varNum = 0; });const newCode = escodegen.generate(ast);console.log(newCode);

Output:

function v1(v2, v3) {    const v1 = v2 + v3;    return v1;}

Here, every declared identifier got renamed with a consistent numbering scheme, respecting the correct scope hierarchy.

2. Custom Rename Mapping

You can also define your own rename map to transform specific variable or function names.

const renameMap = {    x: 'width',    y: 'height',    result: 'sum'};renameDeclarations(ast, id => renameMap[id.name]);

This is great for refactoring, such as renaming variables to more meaningful names.

🧠 How Scoping Works

renamedecl automatically tracks scopes as it traverses the AST.
When it enters a new function or block, it creates a new scope object.
This ensures that two variables named x in different functions don’t get mixed up:

function outer() {    const x = 10;    function inner() {        const x = 20;        console.log(x);    }    inner();}

Both x variables live in different scopes. The renaming logic keeps that distinction intact — so each gets its own renamed version.

🔧 Why Use This?

• ✅ Safe — Respects JavaScript scoping rules
• 🔍 Customizable — You control the renaming logic
• 🧰 Tool-friendly — Works directly with standard AST tools
• ⚙️ Flexible — Use it for obfuscation, refactoring, or static analysis

🧩 Try It Out

You can install it via npm:

npm install git+https://github.com/optinsoft/renamedecl.git

Then import and use it as shown above.

💡 Conclusion

Working with ASTs may sound intimidating at first, but with tools like Acorn, Escodegen, and utilities such as renamedecl, transforming JavaScript code becomes powerful and approachable.

By controlling variable and function names at the AST level, you can safely build tools for code analysis, transpilation, refactoring, or obfuscation — all while preserving the correctness of your original code.

ImportError: DLL load failed while importing _driver: DLL load failed

The reason is that pycuda is trying to load the CUDA DLL from the bin directory:

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.0\bin

I am using the latest version of pycuda available at the moment: v2025.1.2.

pycuda\driver.py:

def _add_cuda_libdir_to_dll_path():from os.path import dirname, jointextcuda_path = os.environ.get("CUDA_PATH")if cuda_path is not None:    os.add_dll_directory(join(cuda_path, "bin"))    return

However, in version v13 of the NVIDIA GPU Computing Toolkit, the DLLs are located in the bin\x64 directory:

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.0\bin\x64

To solve this problem, a new setting CUDA_DLL_PATH has been added to settings.ini, which contains the full path to the CUDA DLL.

settings.ini:

[settings]CL_PATH=C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\bin\Hostx64\x64CUDA_DLL_PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.0\bin\x64

The latest versions of gen_eth and gen_trx are available on GitHub:

• https://github.com/optinsoft/gen_eth
• https://github.com/optinsoft/gen_trx

PS. If the following error occurs:

pycuda._driver.LogicError: cuModuleLoadDataEx failed: device kernel image is invalid

then you need to update the NVIDIA video driver: https://www.nvidia.com/en-us/drivers/

For the blog migration, I wrote a powershell script called wp-hexo-convertor, which is available on GitHub.

Prior to migration, the WordPress blog was converted to a static version. The wp-hexo-convertor utility was then used to generate posts and redirect pages for Hexo. These redirects are essential to prevent the loss of organic traffic from Google search.

The redirects are implemented via the hexo-generator-alias plugin. I created a GitHub fork that uses the url_for function instead of full_url_for.

Version 2.11 of the IP List Generator has been released.

What’s New

New feature: find ISO country code for the country associated with the IP address.

IP List Generator uses MaxMind’s GeoIP2 binary database (MMDB) to resolve country by IP.

Web Proxy Checker also uses this database to find the country of the proxy by its IP.

MD5 List Generator has been renamed to HASH List Generator.

What’s new: calculating SHA1, SHA-256, SHA-384 and SHA-512 hash values.

Account Verifier allows to check the validity of email addresses.

1. Select Protocol: SMTP.
2. Check “Extract Servers from accounts“ box.
3. Check “MX Lookup“ box.
4. Select Check For: RCPT TO.

Version 1.6.105 of the Opt-In List Manager has been released.

What’s New

Extract And Clean

1. Clean Mail Lists: Remove empty fields (columns).
2. Clean Mail Lists: Custom field (column) delimiters.
3. Clean Mail Lists: The number of output columns. If the source row contains less than the specified number of columns, the list manager will add missing columns (blank). If the source row contains more than the specified number of columns, the list manager will cut extra columns.

Merge E-Mail Lists

1. Keep Email Duplicates (remove full duplicates only).

Misc. Utilites

1. Replace blanks with the specified text.
2. Replace the matched regular expression pattern with the specified text.
3. You can specify field (column) numbers to modify (add prefix, suffix or replace the text).
4. Calculate SHA1, SHA-256 and SHA-512 hash values.

Version 1.21 of the Websites Loader 1.21 released.

What’s New

Replace Rules has been added. Replace rule applies to HTML content and allows, for example, replace one domain by another.

Each rule consist of the pattern, which is regular expression, and the replacement value. Matching text will be replaced with the replacement value.

Replacement value can contain references to matching groups. Example:

Pattern: (https?://)?(localhost/)Replacement value: $2Subject: http://localhost/aaaResult: localhost/aaa

Tags: load, Regular Expression, website

Version 1.3.95 of the Opt-In List Manager has been released.

What’s New

Extracting emails from the various sources has been improved. Now it can extract emails from:

• Archive files. Supported formats (file extensions): ZIP, JAR, EXE (self-extracted archives), TAR, GZ, TGZ, CAB, BZ2, TBZ.
• XLSX files (Microsoft Excel Open XML Format Spreadsheet).
• XLS files (Excel 97/2003).

Tags: Archive, GZIP, TAR, XLS, XLSX, ZIP

Account Verifier 1.30 has been released.

This application allows to check SMTP, POP3, IMAP, FTP and HTTP accounts.
It has multi-threaded architecture and supports SOCKS and HTTPS proxies.

The MaxMind DB file format is a database format that maps IPv4 and IPv6 addresses to data records using an efficient binary search tree.

MaxMind provides variety APIs for lookup IP information in their database: for C, C#, Go, Java. But, unfortunately, API for Delphi is missed. MMDB Reader project solves this omission.

Tags: Delphi, Geo IP, IP, MaxMind, MMDB, Reader

New versions of Copy Manager and ZIP Manager support the double asterisks in source patterns.

The double asterisk (**) followed by backslash (\) will cause to recursive inclusion of files from all subdirectories.

Example. Directory structure:

path\f1\
path\f1\a1\
path\e2\
path\e2\a1\
path\e2\b2\

Pattern path\*\*.txt matches *.txt files in subdiretories path\f1\ and path\e2\ (but NOT in path\, path\f1\a1, path\e2\a1\, path\e2\b2\).

Pattern path\**\*.txt matches *.txt files in path\ and in all subdirectories (path\f1\, path\f1\a1\, path\e2\, etc.).

Pattern path\f**\*.txt matches *.txt files in all subdirectories of path\ starting with f: path\f1\, path\f1\a1\ (but NOT in path\, path\e2\, etc.).

Pattern path\**\a1\*.txt matches *.txt files in path\f1\a1\ and path\e2\a1\.

Tags: Double-asterisk

Domain Resolver 1.1 has been released.

This tool allow to convert a list of domains to a list of IP addresses.

Tags: Domain, IP, Resolve