Anonymity in Human Emulator Studio. Profile.

Anonymity in Human Emulator Studio. Profile.

After reading the previous articles from the series Anonymity in Human Emulator Studio:

Managing embedded browser information.
Cookies, cash and more.
The location.
Browser fingerprints.

We have learned how to adjust the level of anonymity we need in the program. And now a completely legitimate question arises, how can we preserve and use all this splendor at the right time.

What is a profile?

Let’s say we have a task to log into some social network under different users with different settings, and at the same time it is necessary that all settings are the same for each login, including such settings as proxies, browser fingerprints, etc.

A profile will help us cope with this task. A profile is a collection of different settings that we can save and load. You can work with profiles in two ways using commands and the profile dialog.

When working in the Isolated browsers mode, in the tabs of each bookmark, you can set your own profile, if the Isolate browsers in Tabs checkbox is not checked in the settings, then one profile applies to all browser bookmarks.

After restarting the program, the profile is reset, so if you need to use the same profile that you used before restarting it, be sure to load it.

Profile dialog.

With the help of the profile dialog, we can see all the settings that are included in the profile, as well as configure them, save or load, set them by default.

The dialog can be opened using the Profile context menu. To do this, we right-click on the browser tab and in the menu that appears, click on the Profile item.

Or for this purpose you can use the button Profile in the top toolbar of the built-in browser of the program.

After that, we will open the Browser Profile dialog at the current setting.

The Browser Profile of Current Tab dialog


The dialog consists of the following tabs: Description, Cache|Cookies, Proxies, Languages|Accepts, Hardware, Application, Window, Geolocation, Internationalization, Web GL, Audio and Other.

From the name it is not difficult to guess what each tab of this dialog is needed for, but let’s consider each tab separately.

Description.

Description tab

On this tab, we set the Name and Description of the profile.

Cash|Cookies.

Cash|Cookies tab

Using this tab, set the path to the folder with Cookies and Cash.

Please note that since version 7.0.37 (2019.08.21) the cache folder is not configured separately, but is stored inside the cookie folder. That is, the command and setting for specifying the path to the cache folder will not work. These changes are related to changes in the work of the Chromium engine.

Proxy.

Proxy tab

This tab of the profile dialog is used to configure proxy/socks. Also on this tab there is a button Use TOR. This button sets the proxy setting socks5: //127.0.0.1: 9150 to work through the toro. In this case, the Tor should already be running on your computer.

Languages ​​and Acceptances.

Languages ​|Accepts tab

This tab is used to set the language parameters in the navigator and in the HTTP Accept request header. The language can be selected as from the existing one, or register your own, or set a random one by clicking on the dice icon.

Here and elsewhere, the Default value indicates that these values ​​will not be replaced, but those that are by default will be used.

To set the use of default values, you can click the Default button or write this text in the field for the specified value.

Hardware.

Hardware tab

Using this tab, we configure the parameters of the hardware used – the screen resolution, and the parameters of the navigator Platform, CPU Class, Hardware Concurrency, Device Memory, as well as the parameters of the touch screen, the parameters navigator.maxTouchPoints and window.ontouchstart, and the parameter devicePixelRatio.

You can read about these options in the article Managing Browser Information.

Application.

Application tab

On this tab, change the following User Agent string parameters, as well as the navigator Product, Product Sub, App Name, App Code Name, App Minor Version, Vendor, Vendor Sub parameters.

You can read about these options in the article Managing Browser Information.

Window.

Window tab

Everything is simple here, the first field is the width of the browser window, and the second field is the height of the window built-in browser .

Geolocation.

Geolocation tab

Setting navigator.geolocation.getCurrentPositionLatitude, Longitude, Accuracy, Altitude, Altitude Accuracy, Speed ​​( travel speed), Heading (direction of travel (in radians)).

And also you can set here the Time Zone.

You can read more about these parameters in The location.

Internationalization.

Internationalization tab

In this tab, the parameters of internalization are set, which can be found in the article The location.

Web GL.

Web GL tab

This is the profile dialog tab used for working with Web GL Fingerprint. Read about Web GL Fingerprint in the Browser Fingerprints article. If you set the check box Randomize Web GL Fingerprint, then it enable the substitution of all the parameters listed below. If the check box is not checked, the default values ​​are used, provided that Web GL is not disabled in the settings.

Audio.

Audio tab

From version 7.0.43 added the Audio tab.

This tab distorts the AudioContext Fingerprint. You can find out more about audio prints in our article Browser fingerprints. Values ​​for the Audio Noise field can be from 1 to 999999, Frequence Noise can be from 1 to 99.

Other.

Other tab

On this tab, we manage the referrer, canvas fingerprint (To Data URL), Bounds noise and plugins information. Read about Canvas Fingerprint and Font Fingerprint in the article Browser Fingerprints, about plugins in the article Managing Browser Information. Since version 7.0.43 the Bounds noise field has appeared. This field is used for working with Font Fingerprint. Its value can be from -1 to 999999999. At -1, distortion is disabled.

After we have set all the necessary profile settings, we save it as a json file using the Save button. In order to use the saved profile, you need to load it using the Load button.

Manage profile settings using commands.

Everything that we set in the dialog can be set using the appropriate commands.

Here’s an php example all the commands used to configure a profile:

In order to use the profile, use the command:

Working with profiles is constantly being improved, so you can discuss this article and make your comments or suggestions about profiles on our forum.

Human Emulator Runtime(RT)

What is Human Emulator Runtime (RT)?

Many of our clients have noticed that the folder with Human Emulator or Human Emulator Studio has long had another exe file with the abbreviation RT XWeb Human Emulator MT RT.exe and XWeb Human Emulator Studio RT.exe. Unfortunately, not everyone knows why this version of the program is needed. In this article, we will talk about it in detail.

What is Human Emulator Runtime (RT)?

This is a special stripped-down Runtime version of the program that disables all unnecessary interface elements. This version is recommended when working in multithreaded mode.

Human Emulator Studio Runtime (RT) window

Why do I need a Runtime version of the program?

The Runtime (RT) version was created in order to optimize the program’s work with scripts in multithreaded mode and remove all unnecessary loads on the system. Because with a large number of simultaneously running versions of the program, system resources were spent on rendering various dialogs and panels, which are not necessary when working with already written and fully debugged scripts. This version has no restrictions on functionality and can execute any scripts written in the full version of the program.

Separate RT version packages.

Not so long ago, the Runtime (RT) version was separated into separate packages and is now sold to all customers who already have any human Emulator Studio, Human Emulator, or Human Emulator Studio Single license. You can buy the package you need in the user panel.

You can also deliver this version to your clients along with your own scripts to all script developers.

This process looks like this: the developer buys a suitable package for the number and price of Runtime versions – 1, 5, 10, 20 licenses. The larger the package, the cheaper it is. And then grants the license to your client. Activation is performed in the developer dashboard in a separate table with Runtime licenses. The developer determines the price for the RT version for their clients.

Table with RT versions in the user panel

For more information about how you can earn with Human Emulator, see our blog article about how to start earning with Human Emulator

Read more about version of the Human Emulator in Wiki.

Parsing a site with dynamic content

Dynamic content webscraping using the Human Emulator

Dynamic content is site content that is loaded after the main page of the site is loaded. This can be any data that is loaded onto the page, for example, using JS scripts. If you look at the source code of such a page, then this data will not be there. Data loading using scripts is used by online stores, sites for displaying various financial data, statistics sites, banking sites, etc. Parsing such sites without the participation of a browser will be a rather time-consuming process, since you have to understand how scripts work and try to emulate requests in order to simulate the operation of a browser. This requires some knowledge and a lot of time. Moreover, this work will have to be done for each site from which you need to parse such data.

Parsing dynamic content in the Human Emulator is much easier, since all content is loaded into the built-in browser and you don’t need to imitate anything, you just need to parse the data of interest. The algorithm of actions is very simple:

  • go to a web page
  • waiting for data loading
  • parse a data

As an example, we will get the Key data from the Nasdaq website for a few stocks as MSFT, BABA, AAPL and AMZN.

Php example:

Result is:

If you need collect data in real time you just run the script each 10 seconds and get all results with changing.

For example we need to collect data of Stock Activity.

Then the our php script will be:

Result is:

It is not difficult to guess in this way you can receive data for any period of time. At the same time, using the script schedule, you can run such a script before opening trades and receive data during the entire time the trades are in progress.

Launching Human Emulator Studio from the command line.

Launching Human Emulator Studio from the command line.

Command line options in Human Emulator Studio.
/port: “port” – indicates on which port the program is launched to receive control commands. If this parameter is not specified, the port is taken from the port.txt file in the Settings folder of the program. The port can be from 1 to 65535. For example, the /port: “7010” parameter – sets the port 7010 on which the program is running.

/script: “path to the script” – with the help of this parameter we specify which script to run in the program for execution. If the path to the script is not specified, the program is launched without executing the script. The path must be absolute, that is, for example: “C:\XWeb\Human Emulator Studio\My Scripts\1.php

/script_args: “space separated arguments” – arguments to be passed to the script being run. This parameter is used to pass any data to the script. For example, we pass: “7010 ‘1.txt’ 5″. All these values ​​will be placed in the array $argv[], that is, $argv[1] = 7010, $argv[2] =’1.txt’, and $argv[3] = 5. In this case, always $argv[0] = “path to the running script”, if the path is not specified then $argv[0] will be empty. The /port: parameter tells the whole program on which port to run, and to run the script, the port must be passed through the /script_args: parameter.

/browser_command_line: “space separated commands” – command line arguments for the Chromium browser. For example: /browser_command_line: “- disable-gpu —disable-headless-mode”. A list of available commands can be found here https://peter.sh/experiments/chromium-command-line-switches/.

/settings_folder: “path to folder” – path to the folder with settings. By default, all settings are stored in the Settings folder, which is located in the program folder. Using this parameter, you can specify a folder with settings for the program from anywhere. The path must be absolute, that is, for example: “C:\XWeb\Human Emulator Studio\Settings1

/cookies_folder: “path to the cookie folder” – set the path to the cookie folder. The path must be absolute, that is, for example: “C:\XWeb\Human Emulator Studio\7010\cookies_1

/cache_folder: “path to the cache folder” – set the folder to the cache folder. This is an obsolete parameter, since the cache folder is currently automatically placed inside the cookie folder.

/ask_port: “true” or /ask_port: “1” or /ask_port: “yes” – when starting the program, do not ask questions about switching to the next free port, if the current port is busy, then simply do not start the program.

/in_tray: “1” or /in_tray: “true” or /in_tray: “yes” – when launching, hide the program to the tray (system tray).

/hide_tray_icon: “1” or /hide_tray_icon: “true” or /hide_tray_icon: “yes” do not show the icon in the system tray (system tray).

/as_unicode: “1” or /as_unicode: “true” or /as_unicode: “yes” – the script is run in unicode format.

from version 7.0.44

/password: “psw” – to set the Password at startup setting.

/browser: “Chromium” or /browser: “Firefox” – select the browser model in which the script will be executed.

from version 7.0.47

/default_profile_path: “path” – to set the path to the default profile file.

from version 7.0.52

/decode_script_password: “password” – to pass the password when running the encoded script.

If the above parameters are not specified when starting the program from the command line, then the values ​​are taken from the program settings or take the default values.

Run the program from the command line.

How to run a program with command line parameters.

There are many ways to run with command line parameters. Consider the following:

Option 1 through a shortcut on the desktop.
Option 2 via a .bat file.

Desktop shortcut.

To do this, create a shortcut on the desktop, and then specify the command line launch parameters in the shortcut settings.

Our command line will be as follows:

/port: “7010” /script: “C:\XWeb\Human Emulator Studio\My Scripts\1.php” /script_args: “7010 ‘1.txt’ 5 “

Php script code to run from the command line:

After starting the program through this shortcut, the 1.php script will run and the following information will be displayed in the debug window:

Now, every time you run through this shortcut, we will run a script with the parameters specified in it.

Batch file

Batch file (.bat) are ordinary text files containing a set of commands and having the .bat extension. Any text editor will do for editing such a file. In this case, if you double-click on the file, then it will not open in the editor, but will execute the commands written in it.
In our case, we will register in this file the launch of the Human Emulator Studio program and pass command line parameters to it.

So, let’s run the program with the following command line /port: “7012” /script: “C:\XWeb\Human Emulator Studio\My Scripts\1.php” /script_args: “7012 ‘2332.txt’ 1123 ″. For clarity, we will run the program on port 7012 and use other arguments in this case.

Create a batch file and add the following line to it:

start “XHE Studio” “C:\XWeb\Human Emulator Studio\XWeb Human Emulator Studio.exe” /port: “7012” /script: “C:\XWeb\Human Emulator Studio\My Scripts\1.php” /script_args : “7012 ‘2332.txt’ 1123 ″.

The script will run the same one that was launched through the shortcut.

After starting the file, the program will open with the launch of the 1.php script for execution. After running the script, the following information will be displayed in the debug window:

Unlike a shortcut using a bat file, you can run several programs at once if you have a multi-threaded version of Human Emulator Studio.

In this case, our bat file will be like this:

start “XHE Studio” “C:\XWeb\Human Emulator Studio\XWeb Human Emulator Studio.exe” / port: “7012” / script: “C:\XWeb\Human Emulator Studio\My Scripts\1.php” /script_args : “7012 ‘2332.txt’ 1123 ″.
ping -n 2 localhost> nul
start “XHE Studio” “C:\XWeb\Human Emulator Studio 7011\XWeb Human Emulator Studio.exe” /port: “7011” /script: “C:\XWeb\Human Emulator Studio 7011\My Scripts\2.php” /script_args: “7011 ‘file.txt’ 123121 ″
.

Based on the results of the script, two programs will be launched and each of them will execute its own script.

You can read more about batch files and the commands they use here https://sysadmin.ru/docs/bat.

Autoclicker for browser using Human Emulator

Autoclicker for browser using Human Emulator

Autoclicker is a program that records all actions related to mouse and keyboard control and then reproduces all these actions automatically. Accordingly, an autoclicker for a browser is a program that repeats the necessary actions in the browser.

All versions of the program have all the necessary tools for recording and controlling the keyboard and mouse. For recording, the Macros tool is used, which records your actions in the browser built into the program.

Macros.

Working with Macros is described in the article User actions record using tool the Macros. This work is identical in all versions of the program. The only thing is that to write an autoclicker, you will need to select the Full mouse emulation and Full keyboard emulation checkboxes in the Macros settings. In this case, a real keyboard and mouse will be used.

Keyboard simulation.

To control the keyboard, the keyboard object has been added to all versions of the program. This object provides complete control over all keyboard capabilities. And in two modes: full keyboard simulation and transfer of events from the keyboard to the browser.

Full keyboard simulation.

In full keyboard emulation mode, Human Emulator controls input from a real keyboard, that is, it sends events as if a real person presses keyboard keys. In this case, all actions with the keyboard will be performed in any active window, be it a window of the built-in browser program or an open Notepad window.

An example of working in php in full emulation mode:

An example of keyboard input into an open Notepad window for programs based on Internet Explorer:

In Human Emulator Studio, working with the input command is slightly different, so in order to perform the same action as in the example above, you either need to use the clipboard:

Or use the functionality to manage external windows.

An example on php for working in Studio:

Passing events from the keyboard to the browser.

The second mode is event transmission. In fact, when you work with the keyboard, after each keystroke, the active window of the program receives a number of messages and the corresponding action is performed based on these messages. Moreover, this event moves from one active window to the next. That is, when you enter text from the keyboard into a text field in a browser, this message is received first by the browser window, and then through the chain of parent elements and the text field, as well as all its child elements.

Thus, you can work simultaneously in several dozen browsers, while in full emulation mode you can work with only one active browser window, as is the case with real keyboard use. All commands for sending events of the keyboard object have the send_ * prefix.

An example of sending events to php:

In addition to the keyboard object commands, all HTML DOM objects have send_keyboard_input_by_ * commands. These commands pass keyboard input events to the HTML element.

Mouse simulation.

To control the mouse, the mouse object has been added to all versions of the program. As with the keyboard, you can also work with the mouse in two modes: full emulation of mouse actions and transmission of events from the mouse to the browser element. The principle of operation is the same and with the keyboard, full emulation of the use of a real mouse cursor, and in the event transmission mode, all events from the mouse are transmitted to the element.

Full mouse simulation.

Working with a real mouse. In this mode, the real mouse cursor will be used and during the execution of mouse actions, it will be possible to observe how the cursor on the monitor moves across the screen. For complete emulation, the corresponding commands were added to the object. With the help of these commands, you can perform all the actions that a person can perform with a real mouse: perform clicks on different buttons, spin the wheel, pinch and release buttons, move the cursor.

An example of using full emulation in php:

The example above moves the mouse cursor to a specified point on the page, holds down the left mouse button and moves the cursor to new coordinates. After completing this example, a portion of the text on the page will be selected.

Example of mouse clicks in an outer window in an IE based Human Emulator:

An example of mouse clicks in an outer window in Chromium-based Human Emulator Studio:

Passing mouse events.

To send events directly to the browser, use the send_ * prefix commands. Unlike full emulation commands, these commands allow you to work even with a minimized program window and are suitable for multi-threaded work.

An example of sending mouse events to php:

Through the functionality of the windowinterface object (an interface for managing external windows), you can not only work in full emulation mode, but also send mouse events to these windows.

Element interface.

Another way to work with the mouse and keyboard with page elements in a browser is to use the functionality of connecting to an element through an interface.

To obtain this interface, one of the commands available from any DOM object of the program is used.

After we have received a link to the interface, we use the commands: Full mouse emulation over the element, Mouse emulation at the event level over the element, Full keyboard emulation over the element, Keyboard emulation at the event level above the element.

In this case, our example for a full keyboard and mouse emulation to work with a google textbox would be:

and sending the event to the same field will look like this:

A random trajectory of the mouse.

When the command move the mouse cursor move or send_move is called, the mouse cursor moves in a straight line from the starting point to the point specified in the command. But sometimes it becomes necessary to move the mouse along complex and random trajectory, that is, as a person would do by viewing the page or reading text on it. For this purpose, the move_to and send_move_to commands have been added to the program. These commands move the cursor along random trajectory in the form of a line, curve, chaotic movement, along a circular path and along a trajectory to simulate text reading.

Php example:

Autoclicker based on Human Emulator.

As you can see from this article, all versions of the Human Emulator have enough functionality to use it to make not only a browser autoclicker, but also an autoclicker for external windows.

Record user actions in the Human Emulator Studio browser using the Macros

User actions record using tool the Macros

In the article we in detail explain how you can use the Macros in the Human Emulator Studio.

One of the first tools built into the program, which was added to simplify the creation of scripts, is the Macros.

How does it work?

When you enable the Macros, your actions in the browser are recorded, such as going to pages in the browser, all possible clicks on elements, and entering data in various browser fields. In this case, there are two modes of operation, this is when all actions are recorded via mouse control or using functions for working with individual objects.

Configuring the Macros

Before you start recording, you need to configure the Macros. The Macros settings are located in the General settings of the program, the Macros tab.

Now let’s go through all the settings.

Add focus by click — when you select this check box, the focus command will be added to each of your clicks.
Add mouse move to click — when you select this check box, the send_mouse_move command will be added to each of your clicks.
Add pause to click — if you select this check box, the sleep(1) command will be added after each click, i.e. wait for one second.

In other words, when you select these settings, your code will look like this:

without selecting these settings like this:

Check boxes Full mouse emulation and Full keyboard emulation. When you select these check boxes, functions will be substituted that fully emulate mouse movements and keyboard input to the active window. When script run in full emulation mode you will not be able to use your computer or work in multithreaded mode, as any actions with the mouse cursor or using the keyboard may interfere with the script.

In the script code it will be like this:

and

instead of

The group of radio button Catch events. In this group, exhibited the device of the action which will be to record a Macros.

When you select the Mouse, all actions in the script will be recorded as actions with the mouse.
In the script it will be written like this:

When you select the Keyboards option, all input actions will be recorded via the $keybord object
in the script, this will be

If the item Click on elements is selected, then writing to the script will go through the objects of these elements.
In the script :

The radio button group Create function. Responsible for the priority parameter with the program define the element to work with. By default, the item is selected Auto, in other words, the item is determined by the first available parameter, starting with the item ID and ending with the item number.

The check box Create new script. If you select this check box, a new script will be created when you start recording the Macros and all actions will be recorded in this script. If the check box is removed, then the entry will go to the current script, in the place where the carriage is installed in the editor.

Start the Macros

Use the Actions menu to enable the Macros.

Press menu item Start Record or use hotkey Ctrl+Shift+R.

Create simple script using the Macros.

Now let’s write a simple script. In built-in bowser enter google.com and press Go.

Turn on the Macros using menu item Start Record. Enter phrase human emulator in the Google search field. Press Enter. Click on the first link in the output. Turn off the Macros using menu item Stop Record. And we have the script like as:

Slightly change the Macros settings and disable the check boxes with focus, mouse movement and pause. And instead of Enter, press the Google search button.
We get the script like as:

Features of working with the Macros.

As it is not difficult to notice, the work in the Macros goes through the Dom Interface of objects. That is when you get the element itself you can do various actions with it such as:

Actions with an element
click – click on an element
meta_click – focus, move the mouse to the element at random coordinates, and click
event – send an event to the element
check – check the element
focus – set the input focus on the element
scroll_to_view – scroll the page so that the element is visible (via java script)
ensure_visible – scroll the page so that the element is visible (via scrolling)
scroll – scroll the element
screenshot – take a screenshot of an item

Change an item
set_value – set a value
set_inner_text-set internal text
set_inner_html-set internal htmlml
add_attribute – add an attribute
set_attribute – set an attribute
remove_attribute – remove an attribute

etc.

And all these actions can be performed with any element, be it a anchor or a button. You can also get a page element as an interface using the same functions for all page elements:

Getting the DOM interface
get_by_number – get the DOM interface by number
get_by_name – get the DOM interface by name
get_by_id – get the DOM interface by id
get_by_inner_text – get the DOM interface by internal text
get_by_inner_html – get the DOM interface from internal html
get_by_outer_text – get the DOM interface from external text
get_by_outer_html – get the DOM interface from external html
get_by_href – get the DOM interface by href
get_by_alt – get the DOM interface by alt
get_by_src – get the DOM interface by src
get_by_value – get the DOM interface by value
get_by_attribute – get the DOM interface by attribute value
get_by_properties – get the DOM interface by the value of several properties
get_by_xpath – is to obtain the DOM interface by its XPath

In other words, as in other functions, we work with page elements by several parameters, such as name, id, sequence number, and so on. All this can be viewed through the element inspector or use the same context menu.

Use of macros.

The macros is useful when you need to write simple scripts or some parts of scripts, when you can’t define some elements with other tools. At the same time, you should understand that the scripts recorded by the Macros will still have to be edited, since we use the Macros to record actions with page elements. You can add commands that are not related to page elements using another tool, the code Helper.