Posted on 02/03/2016 in
General information
The plugin's programming interface involves calling asynchronous operations implemented based on promise objects. You can read more about the specification used in the implementation of the plugin. You need to install two types of handlers on promises:
- onFulfilled– fire when the promise is in the “successful” state;
- onRejected– fire when the promise is in the “completed with error” state.
Initializing the plugin
To work with the plugin, you need to call the initialization function of the PKCS#11 component plugin.initPKCS11 . This function takes a list of module names (in the form of an array) as parameters. The list of provided modules can be viewed. If modules are not specified, the plugin will initiate all modules.
If you need to indicate which crypto providers should be used when running the capi module, you should use the following recording format:
Capi:(prov1),(mode):(prov2),(mode)
In this entry:
- prov1, prov2 – name of the crypto provider. The following values are currently supported:
- Crypto-Pro GOST R 34.10-2001 Cryptographic Service Provider;
- Crypto-Pro GOST R 34.10-2012 Cryptographic Service Provider;
- Crypto-Pro GOST R 34.10-2012 Strong Cryptographic Service Provider;
- Signal-COM CPGOST Cryptographic Provider;
- Signal-COM GOST R 34.10-2012 (256) Cryptographic Provider;
- Signal-COM GOST R 34.10-2012 (512) Cryptographic Provider;
- Infotecs Cryptographic Service Provider.
- mode – display mode of the PIN code entry window. Can take the following values:
- 0 – default mode provided by the crypto provider;
- 1 – display of the native crypto provider window.
Note: When working with Crypto-Pro on Linux, displaying the native crypto provider window is not available. - 2 – displays a window in the plugin interface.
Note: when working with Signal-COM, displaying the window in the plugin interface is not available.
To obtain keys from the system Windows storage should be specified as the provider
Example of initiating all modules:
Plugin.initPKCS11(["ISBC ESMART", "Aladdin R.D. Unified JaCarta", "Rutoken", "SafeNet", "capi:Crypto-Pro GOST R 34.10-2001 Cryptographic Service Provider,0:Crypto-Pro GOST R 34.10-2012 Cryptographic Service Provider,0:Crypto-Pro GOST R 34.10-2012 Strong Cryptographic Service Provider,0:Signal-COM CPGOST Cryptographic Provider,0:Signal-COM GOST R 34.10-2012 (256) Cryptographic Provider,0:Signal-COM GOST R 34.10-2012 (512) Cryptographic Provider,0:Infotecs Cryptographic Service Provider,0:
An example of initiating a module to obtain keys from the Windows system storage:
Plugin.initPKCS11(["capi:
Upon successful initialization, the function returns an object (hereinafter using the promise mechanism) that has the modules and getCertsForSign functions.
Viewing a list of modules and their status
To view the list of modules and their status, you need to call the modules function.
Example request:
Pkcs11.modules.then(onFulfilled, onRejected);
An example of a function response (breaks are given for ease of reading):
[ ( "enable": true, "name": "Aladdin R.D. Unified JaCarta" ), ( "enable": true, "name": "Rutoken ECP" ), ( "enable": false, "error": "100 :failed to load p11 module", "name": "ISBC ESMART" ) ]
View the list of certificates
To view the list of detected certificates, you must call the getCertsForSign function. As a function call parameter, you must specify whether parallel mode of polling initialized PKCS#11 modules should be used:
- true– parallel access to modules (recommended mode);
- false– sequential access to modules.
View information about a specific certificate
To view information about a specific certificate, you need to call the full_info property, which returns information about the certificate as a json object. It includes the following parameters:
- sn – serial number certificate;
- subject– information about the subject to whom this electronic signature certificate was issued. Returned as json in the format "parameter: value", where parameter is the name of the corresponding object identifier (OID). All standard object identifiers are given common designations, for example, CN (Common Name).
- issuer– information about the issuer of the electronic signature key certificate. Returned as json in the format "parameter: value", where parameter is the name of the corresponding object identifier (OID). All standard object identifiers are given common notations;
- not_before– certificate validity start time (data type – string in ASN1_TIME format);
- not_after– certificate expiration time (data type – string in ASN1_TIME format);
- key_usage– information about the purpose of the key is returned as an array.
Viewing electronic signature key data
To view information about a specific digital signature key of a certificate, you must call the token_info method. The method returns a json object with the following data:
- label- Name key container electronic signature tools;
- manufacturerID– identifier of the manufacturer of the electronic signature tool;
- model– model of the electronic signature tool;
- serialNumber– serial number of the electronic signature tool.
Signing operation using the selected certificate
Simple signing mode
To sign a string using the selected certificate, you must call the cms_sign_on_it function, which accepts the following input parameters:
- signature line;
- signature type - whether the signature is attached (must be true) or detached (false).
An example of a function call that should be called on a certificate object: cms_sign_on_it("1234", 3, true).then(function(cms)(console.log(cms)));
Advanced signing mode
Advanced mode allows you to:
- sign large amounts of data, such as files;
- sign multiple files without asking for a PIN code again.
To sign data using the selected certificate, you must first initialize the signer object using the start_signing function on the certificate object. Function parameters:
- signature type - whether the signature is attached (the value true must be passed) or detached (false);
- number of attempts to enter a PIN code (for example, a value of “1” means that the user has only one attempt, after which the function returns an error).
The following methods will be available on the signer object:
- add_data_in_hex(hexDataString) - accepts data as input as a hex string;
- add_data_in_base64(base64DataString) - accepts data as input as a base64 string;
- add_data_in_string(stringData) - accepts input data in the form of a utf-8 string;
- free() - returns true/false, which allows you to check that the certificate is ready to be signed. Required to be used for the case when several iterations of the signature are carried out on different certificates. In other words, if you are performing sequential signing on several certificates, then before signing you need to call this method and make sure that it returns true ;
- finish() - finalizes the signature and returns it in CAdES-BES / PKCS#7 format.
Signing the line
An example of a command to sign a string:
Signer.add_data_in_string("1234").then(function(res)( return signer.finish();)).then(function(cms)(console.log(cms)));
In this command, “1234” is the line that needs to be signed.
Installing multiple signatures
After the signature is finalized, the signer object returns to its original state. It can be reused within a session to sign other data, for example a new file. In this case, the PIN code will not be requested again.
To sign on a different certificate, you must clear the signer object. In most browsers, this object is cleared automatically when it leaves the scope. However, in Internet Explorer There may be situations where the signer is not cleared, which leads to an error. To avoid the error, it is recommended to explicitly clear signer.free() . This operation can be performed in all browsers to unify the code. An example of a signature on a certificate with the signer object cleared:
Function sign(cert, info) ( function successCms(signature) ( alert(signature); ) cert.start_signing(false, 3) .then(function(signer) ( signer.add_data_in_base64("MTIzNDU2") .then(function() ( var data = signer.finish(); var free = signer.free(); return data; ), e).then(successCms, e), e);
Signing a large file
Function readFileByChunk(file, cbToRead, cbToFinish) ( var fileSize = file.size; var chunkSize = 1024*1024; // bytes var offset = 0; var chunkReaderBlock = null; var self = this; var readEventHandler = function(evt) ( if (evt.target.error == null) ( cbToRead(evt.target.result, offset, fileSize); offset += evt.target.result.byteLength; ) else ( console.error("Read error: " + evt .target.error); showError("Error reading file: " + evt.target.error); return; if (offset >= fileSize) ( cbToFinish() return; ) // to the next chunk chunkReaderBlock(offset, chunkSize , file); .webkitSlice) ( var blob = _file.webkitSlice(_offset, _chunkSize + _offset); ) else if (_file.mozSlice) ( var blob = _file.mozSlice(_offset, _chunkSize + _offset); ) r.onload = readEventHandler r. readAsArrayBuffer(blob);
) // start reading the first block chunkReaderBlock(offset, chunkSize, file);
)
It should be noted that since signing is performed locally, in order to subsequently transfer the user-selected file and signature to the server, it is necessary to implement the appropriate logic on the side of the web page. In programming, data initialization is an important task because in this step we define the prerequisites for the application - attributes, required files and data, database connection, etc. WordPress has a fixed initialization procedure. When implementing
life cycle pages, the WordPress platform launches a lot of actions, many of which we have previously covered. The system has a set of initialization hooks that are used to initialize the application before executing its basic functionality. For developers and theme designers, in order to create quality applications, it is very important to understand exactly how hooks are used, as well as what are the most
common mistakes
using initialization hooks.
In this article, we will cover the importance of initialization hooks in WordPress and also show you how to use them in various situations.
Introduction to Initialization Hooks WordPress offers a wide range of hooks that can be used in plugin and theme development. WordPress will finish loading.
Thus, initialization hooks are mainly used to, as you might guess, initialize the process of their work in plugins and themes. Let's take a look at the available init hooks in WordPress in order of execution:
- Init fires after WordPress has finished loading but before any headers are passed. In general, this hook is used by plugins to initialize their work process.
- widgets_init is used to register application widgets in the sidebar. The register_widget function is executed within this hook.
- admin_init is executed as the first action after a user has accessed the WordPress admin panel. In general, it is used to initialize parameters specific to the admin area.
Apart from these three hooks, WordPress also has another hook called admin_bar_init, which is executed after the admin bar has been initialized. The WordPress Codex does not contain a description of this hook, but it is used by only a small number of plugins.
You can learn the full process of performing action hooks in WordPress in the codex.
WordPress executes each hook in a specific order (which is described in the code). It's also important to consider the order in which the events appear in each action hook. Let's look at the following situations to understand the difference.
Defining admin_init inside the init hook
If we need to, we can define WordPress hooks within other hooks. IN typical request init hook executed before the admin_init hook. Let's try to display something on the screen by placing admin_init inside the init hook:
Add_action("init", "test_init"); function test_init())( add_action("admin_init", "test_admin_init"); ) function test_admin_init() ( echo "Admin Init Inside Init"; )
After executing this code, we will get the desired output through the echo statement.
Defining init inside the admin_init hook
Let's look at the code and output of the script when an earlier hook is defined in a hook that comes later in the execution order.
Add_action("admin_init", "test_admin_init"); function test_admin_init() ( add_action("init", "test_init"); ) function test_init() ( echo "Init Inside Admin Init"; )
In this case, we won't get any output - as expected - because the init hook is executed before the admin_init hook, which is not allowed after the admin_init hook is defined.
As you can see, it is very important to understand the procedure for executing hooks to create successful plugins. The order in which events appear is important for all WordPress hooks.
Let's explore the init and admin_init hooks
Among all the initialization hooks, it is very important to pay attention to init and admin_init, since these two hooks are used very often in many plugins. Using all other initialization hooks is much simpler compared to these two hooks.
We'll also look at the functionality of the init and admin_init hooks.
The init hook is executed on every request for both the frontend and backend of a WordPress site.
The admin_init hook is executed after the admin section has completed its boot process. So this hook is executed for all requests to any admin page. Users must be registered in order to take advantage of this hook.
Since both of these hooks are executed on every request, we must consider the functionality based on the implementation of these hooks accordingly, as this can have a noticeable impact on site performance.
How to use init hooks
Initialization hooks are often used by most existing WordPress plugins, and they are very important for managing the process of their execution.
WordPress doesn't tell us exactly what we should and shouldn't include; Therefore, developers can make minor mistakes, which, in turn, can lead to a noticeable decrease in performance. In this section, we will show you how to effectively use the init and admin_init hooks.
Let's take a look at the most best practics using initialization hooks:
init hook
- Registering Custom Post Types – WordPress developers recommend using the init hook to register new custom post types.
- Initializing Plugin Configuration and Settings – Plugin configuration and configuration options need to be defined for each request, which means it is good practice to place them inside this hook.
- Accessing submitted user data (using $_GET and $_POST) – We can intercept the submitted user data without using any action, however in this case it is recommended to use init hook as it guarantees execution for every request.
- Adding new rewrite rules - we can define new rewrite rules using the init hook, however they will only work after a reset.
- Adding or removing custom actions – plugins contain many custom actions to expand functionality. Situations may arise when we need to add new actions or remove old ones. In such cases, it is important to apply these actions in the init hook.
- Loading Plugin Text Domain – WordPress supports numerous languages and thus we can upload a file containing translated strings. This should also be done in the init hook.
admin_init hook
- Access Control – It is important to check the access rights of logged-in users before allowing user access to a specific set of features and functionality. admin_init is the first action that will be executed in the admin area, so we can use it to control access.
- Adding New Options – We can use this hook to add new settings pages or options to an existing WordPress options area.
There are many other possible uses for these hooks, but these features also have their own hooks, so initialization hooks are not required.
Common pitfalls when using initialization hooks
We often encounter situations where developers misunderstand the use of initialization hooks. Using these hooks incorrectly can cause serious performance issues.
Let's identify common errors, as well as ways to work around them:
- Updating rewrite rules is a very resource-intensive operation in which all rewrite rules are updated and reordered to add new ones or remove old ones that are not needed. Many developers update rewrite rules inside init actions. This results in unnecessary performance overhead on every query. We must determine a way manual update rewriting rules using buttons or updating rules for rare actions, such as saving plugin settings.
- Database access – To implement various functionality, you must have access to the database, but it is also important to prevent unnecessary database calls inside initialization hooks, since these are executed on every request. For this purpose, the ideal solution would be to bind database hooks to hooks with specific functionality, avoiding massive performance overhead.
- Implement update procedures – plugins should include update procedures to keep their capabilities up to date in new versions. Typically, developers use initialization hooks to check the plugin version and existing parameters before performing the update process. We may offer users the ability to update the plugin on a separate screen instead of automatically running checks on every request.
- Using initialization hooks instead of hooks for specific functionality is the most common mistake that many developers make. WordPress has a wide range of hooks that provide unique functionality. It's important to use function hooks to avoid conflicts and make your code extensible. Hooks such as init and admin_init can be used instead of specific hooks, so many developers tend to use them without realizing the destructive effect they have.
Examples of common scenarios where developers use the init and admin_init hooks instead of the recommended hooks:
- admin_menu – We can add menu pages using the add_menu_page function. To create pages in the admin menu, it is recommended to use the admin_menu hook. However, many developers use the admin_init hook because it runs after the admin_menu hook.
- wp_enqueue_scripts - The recommended way to add styles and scripts is to use the wp_enqueue_scripts hook. However, many developers use wp_enqueue_script inside the init hook to load scripts and styles.
There are plenty of similar situations where developers use a generic init hook instead of a specific hook for a specific functionality, and this approach should be avoided whenever possible.
Conclusion
WordPress init hooks play a vital role in plugin and theme development. Many developers use hooks incorrectly, creating unnecessary performance overhead. In this article we discussed correct use of these hooks, as well as common errors in their use and ways to work around them.
Now we can apply the same techniques to hooks used in plugins. Many plugin developers use their own action hooks to make plugins extensible. For such plugins, we can define plugin-specific initialization hooks to allow developers to "hang" initialization tasks on predefined hooks.
Hi all! Surely, many users could see the “Failed to load plugin” error on their monitor screen during playback online audio, video, or when trying to launch some kind of flash animation (game, banner, application, etc.). If you landed on this page, then most likely you saw a similar error. Today in this short instruction we will eliminate the error “ Failed to load plugin» in the browser quickly and easily.
First, friends, let's figure out what a browser plugin is. A plugin is, in other words, an addition that expands the capabilities of an Internet browser. There are a huge number of plugins today, and they are all in different directions. Any browser has basic plugins installed in order to display web resources correctly. If a message appears in your browser stating that the plugin could not be loaded, then most likely the problem is Flash Player. Below we will look at several ways in which you can fix this error.
1st method. Updating the Internet browser
This method is the simplest and helps in most cases. I will show all the manipulations using the example of the popular Google Chrome browser. If you use another browser, do not worry, all steps are the same. So, in order to update the browser, go to the menu - Help - About the browser.
On the “About the program” page, find and click on the “Update” button.
After the update, check to see if the “Failed to load plugin” error appears again. If these steps did not help solve the problem, move on to the next method.
2nd method. Clearing history in the browser
This method will help when such an error appears only on some resources. It's quite simple - you need to clear the cache and cookies in your browser.Cache – temporary browser files that store all web components of viewed resources (images, pages, video files, design, etc.). Thanks to the cache, the browser quickly loads pages of previously visited sites, since resource components are loaded not via the Internet, but from local disk computer.
Cookies are also temporary files that store the user’s personal data (logins, passwords, website settings, etc.). When we go to any page, the browser sends all this data to the server, and therefore we can access any resource without re-entering the login and password for authorization.
So, let's clear the Cache and Cookies in our browser to try to resolve the error. Go to the menu, select “History”.
Then click on the “Clear history” button and carefully check that the checkboxes are checked, as shown below in the screenshot.
After this, all that remains is to restart the browser.
3rd method. Disabling unnecessary plugins
If the first two methods did not help, then proceed to disabling the extra plugin. First of all, let's open the page with installed plugins. The address is different for each browser:If you use Chrome, then type chrome://plugins in the address bar
If you use Yandex, then enter browser://plugins in the address bar
If you use Opera, then type opera://plugins in the address bar
If you use Firefox, then type in about:plugins in the address bar
When the page with plugins opens, take a closer look to see if extra plugin Flash Player. If there is one, I recommend disabling it (usually it is of the PPAPI type).
After disconnecting, restart the browser and check again.
4th method. Reinstalling Adobe Flash Player
If none of the methods described above helped, then I advise you to reinstall Adobe Flash Player. To do this, first remove old version flash player in Control Panel - Programs and Features. After download latest version Adobe Flash Player from the official website.
I hope my little instruction about fixing the error " Failed to load plugin"helped you. If you solved this problem in any other way, you can write in the comments, this will help many users! Thank you for your attention and all the best!
Plugin installation rules CryptoPro CSP V Mozilla Firefox differ depending on the browser version - 52 and higher, or older.
Mozilla Firefox versions below 52
To sign documents in Mozilla Firefox:
- Disable automatic update. To do this, go to “Menu” ⇒ “Settings” ⇒ “Additional” ⇒ “Updates” (Fig. 1).
- Install version 51.0.1 from the official Mozilla Firefox website.
To install CryptoPro Browser plug-in, you must follow these steps:
- Download the installation program from the official website of the Crypto-Pro company www.cryptopro.ru/products/cades/plugin and run the executable file.
2. In the installation window for CryptoPro Browser plug-in, click the “Yes” button (Fig. 2-a).
Rice. 2-a. Installing CryptoPro Browser plug-in 3. Wait for the installation to complete (Fig. 2-b).
Rice. 2-b. Installing CryptoPro Browser plug-in 4. Click the “Ok” button and restart the Internet browser (Fig. 2-c).
Rice. 2-in. Installing CryptoPro Browser plug-in Important
After installing CryptoProBrowser plug- inyou need to check whether the browser add-on is installed to work with electronic signature CryptoPro EDS Browser plug-in for browsers.
5. Open the browser, click the “Browser Menu” button, select the “Add-ons” section (Fig. 3).
Rice. 3. Browser menu 6. Open the "Plugins" tab. Opposite the “CryptoPro CAdES NPAPI Browser Plug-in” plug-in, select the “Always enable” option in the drop-down menu (Fig. 4).
Rice. 4. Add-on management 7. Restart your browser.
Mozilla Firefox version 52 and higher
To install CryptoPro Browser plug-in, follow these steps:
- Follow the link www.cryptopro.ru/products/cades/plugin, then select “browser extension” (Fig. 5).
Rice. 5. CryptoPro website
2. Click “Allow” (Fig. 6).
Rice. 6. Request resolution
3. Click “Add” (Fig. 7).
On some sites you have to deal with certificates and electronic keys, and at first you have to solve various problems to make everything work. This article will talk about the CAdES plugin’s error when it is loaded but objects are not created.
Solving the problem with the plugin
As follows from the contents of the error, the CAdES plugin itself seems to be loaded, i.e. it is in the system, but something is preventing it from working. Usually the problem occurs in older versions of Firefox up to version 51 (in newer ones the plugin simply does not work). This article takes an electronic trading platform as an example, and there are three ways to solve the problem.
Method 1: Enable the plugin for the current site
Enabling the plugin only for the current site is justified by security considerations when the browser is used for personal purposes and to open the most different pages. And also if you need to perform a task with electronic keys only once.
Method 2: Enable the plugin for all sites
If the security issue is not much of a concern, because... The computer is used exclusively for working on several sites, you can enable the CAdES plugin for all sites. Then it will work immediately after the page loads. This can also help in cases where it is impossible to find the dark gray square to enable the plugin.
Method 3: Use a different browser
For some unforeseen reasons, the CAdES plugin may still refuse to work. Therefore, another way to resolve the error is to use a different browser. Most browsers are based on the Chromium engine, they are all somewhat similar, so let's look at the example of Google Chrome.
Conclusion
As you can see, there are several ways to solve the problem with the plugin not working correctly. Depending on your preferences and circumstances, you can choose the one that suits you best.
Loading...