Quantum Steganography Based on the B92 Quantum Protocol

Abstract

This paper presents a communication algorithm in which a grayscale image, shared between two parties, can be used to transmit a secret message, by applying the idea introduced in the B92 quantum protocol. The least significant qubits of the pixels’ representation in certain regions of the image are used. With the help of a server, the algorithm generates a random message, which can further act as a secret key for cryptographic algorithms in order to secure the data that two parties might want to exchange later on. The chosen representation of the image is NEQR (novel enhanced quantum representation) and the platform used for testing the described idea is IBM Quantum Experience, along with the open-source Python framework called Qiskit. This solution allows users to design, implement quantum circuits (containing various quantum gates), and simulate them using real devices and local simulators. An implementation using this platform for a sample image and the corresponding results are also presented in this paper.

1. Introduction

Cryptography and its applications present the utmost importance in the classical information processing research areas. The theory and analysis for different cryptographic algorithms used in encrypting day-to-day communication to and from commonplace computers, ranging from social media private chats to internet banking applications, is exactly the part that guarantees that the operations carried out by the average user on the internet can be conducted safely and without much privacy concerns. Now, with the rise of the Internet of Things (IoT) universe, we also have to mention the specially designed algorithms and hardware platforms for the embedded devices, which require new operating conditions, such as low power, a longer life span, and so on—see paper [1] for the challenges met when proposing the architecture of these devices.

Quantum information processing is one of the most promising fields in computer science and engineering, with huge speed-up potential, but also represents a real threat to the security protocols in place in today’s world. Since its beginnings, the emergence of this field has raised the problem of how the classical security protocols would be able to resist the attacks launched using this new technology, as well as how the new quantum algorithms would have to be designed in order to keep the same level of security, without compromising the power usage (and other physical factors). This requires another way of thinking, by also processing the data in a new environment, and by also using the quantum properties, such as entanglement and superposition, to be able to fully utilize the quantum processing power.

Section 2 presents some related papers in the field of quantum cryptographic protocols. Section 3 goes over some of the quantum representation techniques developed by different researchers, briefly presents the core concepts behind the chosen platform (IBM Quantum Experience and Qiskit) used to simulate the algorithm, and then describes the proposed protocol. Section 4 presents the implementation details using a sample grayscale image, the circuits, and the obtained simulation results; it also shows the mathematical formulas on which the illustrated algorithm relies. The final section is the conclusion of the paper and it highlights the main points achieved in this article.

2. Related Work

Multiple quantum algorithms have been proposed over the years, and the following paragraphs present some of the most relevant quantum cryptographic protocols. A comprehensive review of multiple techniques used in quantum cryptography along with their analyses are presented in the paper [2].

One of the best-known quantum key distribution (QKD) protocols is the BB84 protocol (see article [3]). This protocol uses two bases and four states, with two states from each basis; the classical choice is the pair of $\left|0\right.\rangle$ and $\left|1\right.\rangle$ states for the Z basis, and $\left|+\right.\rangle$ and $\left|-\right.\rangle$ states for the X basis. A key point is that that an eavesdropper cannot clone any states (this would break the no-cloning theorem), nor interfere in any other way without Alice and Bob (the two entities used in describing cryptographical protocols) being aware of this fact. For each qubit, Alice encodes her value and sends it to Bob, who measures it using a random basis. The combination between the $\left|0\right.\rangle$ and $\left|+\right.\rangle$ states is translated to a value of 0, while the $\left|1\right.\rangle$ and $\left|-\right.\rangle$ states indicate a value of 1. This combination ensures the non-orthogonality condition and guarantees that the condition cannot be cloned or measured accurately. After transmitting the qubits, Bob also sends Alice the measurement basis he used for each qubit and Alice responds with her measurement basis, at which point, both parties have a common key; after this step, they decide to only keep a random number of these qubits, which will represent the secret key.

Another QKD protocol was proposed in 1992 by Charles Bennett, also known as B92 (see paper [4]). Unlike BB84, this protocol requires only two states for the transmission of a key; Alice encodes each bit by making the following association—for 0, she uses a state of $\left|0\right.\rangle$, from the computation basis $(\left|0\rangle ,\left|1\right.\rangle )\right.$ and for 1, she uses $\left|+\right.\rangle$, from the non-orthogonal basis $(\left|+\rangle ,\left|-\right.\rangle )\right.$. Bob also randomly measures using one of the two bases, and then the key is generated from the states where the measurement results yield $\left|1\right.\rangle$ or $\left|+\right.\rangle$. After this step, in a similar manner to BB84, Bob sends Alice the position of the qubits that he decides to keep in order for both parties to share the secret key.

The authors of paper [5] introduce a new type of quantum key distribution protocol, where the proposed scheme is not only secure in the previously analyzed eavesdropper scenario, but also the case of a theoretical post-quantum eavesdropper. In the beginning, Alice and Bob share a quantum channel, which contains a source that generates pairs of qubits in the maximally entangled state. Alice can pick one of three measurements with basis $x=\left\{0, 1, 2\right\}$ for $\left|0\rangle \pm e^{i\varphi \left(x\right)}\left|1\right.\rangle \right.$, with $\varphi \left(0\right)=\pi /4$, $\varphi \left(1\right)=0,$ and $\varphi \left(2\right)=\pi /2$, while Bob can measure using $y=\left\{0, 1\right\}$ for the measurement described by $\left|0\rangle \pm e^{-i\varphi \left(y\right)}\left|1\right.\rangle \right.$, with $\varphi \left(0\right)=\pi /4$ and $\varphi \left(1\right)=-\pi /4$. In order to maximize the CHSH inequality (see paper [6]), Alice has to measure using the $0$ and $\pi /2$ bases. A combination of measurements using $\pi /4$ by Alice and $-\pi /4$ by Bob gives uncorrelated results; the only case for a strongly correlated outcome is if both parties measure using the $\pi /4$ basis, which leads to creating the secret key.

Quantum image steganography is the art of hiding various types of information inside an image, using the quantum properties of qubits, such as superposition and entanglement. Some of the most recent innovations in this field are mentioned in the following paragraphs.

The authors of paper [7] present a novel watermarking protocol, which combines the NEQR transformation with the Gray transform and the least significant bit (LSB) technique, for the edges of the image. In another watermarking protocol, after the initial expansion of the watermark image, the Arnold transform is used and the LSB method is applied for the embedding step (see [8]). The bit-plane scrambling operation is used, along with utilizing the LSB, in paper [9]. This operation is followed by the Arnold scrambling and the embedding procedure; two keys are used for hiding and recovering the secret message.

Different ideas are also presented regarding an exploiting modification direction (EMD) algorithm (see papers [10,11]); two out of three color channels (R, G, B) are selected in the process of obtaining the key. Paper [11] also shows how EMD and dynamically sharing between subgroups, together with the usage of bit-plane embedding, help achieve a better embedding rate; the quantum circuits and their implementations are also presented. Paper [12] illustrates a method based on the inverted pattern approach; the idea here is that depending on the value (state) of the quantum key, every pixel from the secret image is either inverted or left unchanged in embedding the message. A configurable number of LSBs are used to store the desired key.

Another idea for quantum steganography is presented in paper [13], where the novel enhanced quantum representation (NEQR, see [14]) is used alongside the LSB steganographic technique, this time for illustrating a detection method. The quantum image is broken into multiple blocks, classified into three groups, and their processing may reveal a potential secret message. The probability of the correct transmission of data is described in paper [15], where metrics, such as geometric coherence and ½-affinity coherence, are taken into account, together with an analysis of the BB84 quantum protocol. In paper [16], the authors present a way of implementing the least significant bit-based quantum steganography (LSBq) for multi-wavelength quantum images; the main concept refers to replacing the least significant qubits in the cover image with the qubits corresponding to the secret string. The techniques used for hiding the secret message are the modulo method and the Hilbert scrambling, with good results in attack scenarios on the stego-image.

3. Materials and Methods

3.1. Quantum Image Representation Techniques

In order to implement an algorithm in the field of quantum steganography, an image representation technique has to be used. Some of the ideas proposed over the last years to represent an image with the help of quantum computing include:

• FRQI, flexible representation for quantum images (see [17])—its definition combines information about the pixel colors and positions;
• NEQR, novel enhanced quantum representation (see [14])—the information on the pixel color is saved in the multi-qubit computational basis of the superposition state;
• NCQI, novel quantum representation of color digital images (see [18]), a technique built on NEQR for color (RGB) images;
• QRCI, a new quantum representation model of color digital images (see [19]), takes the idea from NCQI but also combines the bit-plane concept, applied to each color component, to create the quantum state that can define the image.

The NEQR representation has been chosen for this paper, as it has good control of the information for the color component and also gives the user the ability to recover the image in a finite number of quantum measurements. Its implementation and integration in the chosen platform (IBM) can also be conducted more easily.

3.2. IBM’s Quantum Solutions

There are two ways of interacting with IBM’s quantum services, by using IBM Quantum Experience (see [20]) and Qiskit (see [21]), which have been selected to implement and simulate the circuits in this paper. IBM Quantum Experience allows its users to drag-and-drop quantum gates in order to create their circuits, as well as simulate them and analyze the results, either on a simulator or on a real quantum device. This can also be done directly, using the open-source Qiskit framework, written in Python, which gives programmers and researchers the possibility to code directly in their desired IDEs. The main parts of Qiskit are Terra, Aer, Aqua, and Ignis. Qiskit Terra is the collection of tools required for the design at the circuit level. Qiskit Aer is the simulator part of Qiskit; optimized backends, written in C++, can be found here. Various quantum algorithms can be accessed through Qiskit Aqua, while Qiskit Ignis can be used to analyze various metrics for the noise in quantum systems.

3.3. Algorithm Details

This section presents the proposed procedure of using the idea behind the B92 protocol with the help of a grayscale image, considering the classical Alice and Bob—sender and receiver entities, as well as an auxiliary service, which can act as the server. We assume the fact that the random message that Alice would like to send is 8 bits long, so the encoding for this protocol would require 8 pixels of the image.

The first step is represented by a selection phase in which both parties decide what common image to use (from a set of any given images, stored on a server) or allow the server to pick one randomly before any processing takes place. After an image is selected, in order to keep the idea from B92, the server sets to 0 the LSB of all the pixels from the original image (the target ones are the relevant ones). Alice and Bob receive a copy of this image in order to process it locally (and independently from each other). Alice decides what kind of encoding she wants for her pixels and which of them should be used (this part can be extended with various ideas, for processing individual pixels or groups of pixels); for example, Alice’s choices can be grouped into two categories, each of them with two main options:

• Group 1—encoding type: she can decide to select, and then set to a certain value the least significant bit (LSB) of certain pixels, or modify the image to use the number of bits of “1” in the binary representation of the gray value of that pixel;
• Group 2—pixel selection: she can use the first 8 pixels in the first row of the image or the first 8 pixels in the first column; other simple algorithms can be used to indicate the position of the target pixels.

The option from the first group can also be correlated in various ways with the encoding base of the B92 algorithm; assuming Alice chooses the LSB value of the first 8 pixels on the first row in the grayscale representation, we can propose the following association: a bit of “0” (LSB of the current pixel being processed) means that she would like to select the usual computational basis, while “1” means that she would like to use a different one (the non-orthogonal basis, commonly referred to as $\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$, which requires applying a Hadamard gate to her qubit). Once the image is ready (the required bits are processed as needed), Alice sends her image to the server, as well as her options from the two groups. Bob modifies whatever pixel values in his image he desires (he can also use a local program to randomly modify some or all of them), unbeknownst to Alice’s changes, and once finished, he can send the image to the server. Quite obviously, when one of the two parties finishes the processing on his/her part and uploads the image to the server, it must then wait for the other one to finish; at this point, neither Alice nor Bob know what the other party changed in the image.

Table 1. The correspondence between the LSB value of the gray intensity for the selected pixels in the images sent by Alice and Bob to the server, measurement basis, and applied quantum gate in the circuit created by the server.

LSB Value	Measurement Basis	Applied Quantum Gate
0	$\left(\left|0\right.\rangle ,\left|1\right.\rangle \right)$	No quantum gate
1	$\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$	A Hadamard gate

shows the correlation between the LSB value of each gray level and the quantum gate applied by the server on the matching qubit.

Once the server receives both images, it first creates the NEQR circuit for each pixel that belongs to the part of the image that was selected by Alice. The server then compares the images by evaluating the parameters indicated by Alice’s options as well as Bob’s changes, and applies the required transformations by both parties; the circuit that is presented in the following section can be seen as extending one implementation of the B92 protocol (see paper [22]). After the measurements, the results are sent to Alice and Bob.

In other words, in the proposed scheme, the server and the data transmission between it and the two parties play the role of the classical system that intermediates the communication. We assume that all data transmitted between these entities are encrypted using a classical cryptographic algorithm. The ideas described above can be summarized in Figure 1.

The server would represent a secure environment for the classical part of the proposed scheme. Moreover, an important idea, just theoretically described and perhaps showing a more interesting variation to the system illustrated above, necessary to preserve the key concept of the B92 protocol (and, therefore, to protect against eavesdropping attacks), would be the future concept of a quantum server—it should somehow be able to give users access to pairs of shared qubits, required for various quantum algorithms that need entanglement and correlated states. That means that both parties would be aware of the fact that the data stored there is a valid image (without measuring the qubits), while at the same time giving them the possibility of handling it in a low-level manner using quantum gates as well. A fine control such as the one presented allows for measurements on different bases and the successful implementation of various quantum communication protocols. This concept would mostly come down to the internal quantum design of the physical systems that would make the described algorithm, as well as the original B92 protocol, feasible over larger distances and wide quantum computer networks.

4. Results

4.1. Details of the Quantum Implementation for a Specific Image

In this section of the paper, we present the design of the quantum circuit and its simulation results, for the part of the image that involves the pixels from Alice’s selection, using Qiksit (the code being written in Python). The following grayscale image was chosen, with the original color photo available at FreeImages (see [23])—this would be the image that both Alice and Bob would agree to process (or receive randomly from the server), as can be seen in Figure 2.

In order to indicate the position of a pixel inside a grayscale image (with 8 bits per pixel), the NEQR representation uses a number of qubits equal to the bits required to represent the dimensions of the image. Since the image above would require 256 $\times$ 192 pixels, which would translate to 16 position qubits (without the auxiliary ones). For demonstration purposes, the image in the figure above has been rescaled to 8 $\times$ 6 pixels, so that the number of position qubits would be much lower; as far as the algorithm goes, this operation can be an automatic part of what the server is sending to both parties, depending on the quantum computing power (the downscale does not have to be so radical as in this example). Here, we also need to take into account the fact that ancilla qubits are also required.

Therefore, for this simulation, the following 19 qubits are required:

• Eight qubits for the grayscale value representation;
• Six qubits for the pixels’ positions;
• Five qubits for auxiliary calculus, used to control the gray level qubits (depending on the states of the position ones).

The NEQR representation for the first pixel, with gray level 104, is presented in Figure 3 below; the position qubits (qp₀–qp₂ for the row and qp₃–qp₅ for the column component) are first set in superposition using Hadamard gates, and then NOT gates are used, as we look for states of $\left|1\right.\rangle$ for all position qubits at this point. For the first pixel, we are searching for the situation where they are all in state $\left|0\right.\rangle$ immediately after the Hadamard gates, so they all require NOT gates. A couple of controlled-controlled-NOT (CCNOT) gates are required to set the values of the ancilla qubits, such that the final one, anc₄, is set to $\left|1\right.\rangle$ only when all position qubits are in the desired states. This qubit is then used to set the corresponding states for the actual gray value qubits, q₀–q₇. Another set of NOT gates is used, where necessary, to mirror the initial NOT gates and return the position qubits to their initial superposition states. At this point, the gray value qubits can be measured, along with the final ancilla qubit, as illustrated in Figure 3.

By following the procedure described in the previous section, we analyze the following situation: Alice uses the LSB as the encoding type and selects the first 8 pixels on the first row; she decides to alternate between setting her LSB for her pixels as in the following vector: [1, 0, 1, 0, 1, 0, 1, 0]; Bob performs multiple changes to his image, but for the first line he sets the LSB of the first four pixels to 0 and the LSB of the following four to 1.

The server creates the circuit by first setting to 0 the LSB of some of the pixels selected by Alice and then by comparing the received images, where the LSB of the chosen pixels is the one that must be taken into account for the different measurement bases; for the first pixel, Alice chooses the value of 1 for the LSB, while Bob selects 0 (see Figure 4). The quantum gates between the last three barriers indicate Alice’s and Bob’s measurement bases as follows: a Hadamard gate corresponds to $\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$, while the lack of any gate is used to indicate the $\left(\left|0\right.\rangle ,\left|1\right.\rangle \right)$ basis.

Figure 4, Figure 5, Figure 6, Figure 7, Figure 8, Figure 9, Figure 10 and Figure 11 show the resulting circuits, where the described process is repeated for the first 8 pixels (starting in the left upper corner).

Table 2. The selected basis for the LSB by Alice and Bob, their measurement basis, and the expected results.

Qubit nr.	Alice’s LSBs	Alice’s Encoding Basis	Bob’s LSBs	Bob’s Encoding Basis	Result
q[0]	1	$\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$	0	$\left(\left|0\right.\rangle ,\left|1\right.\rangle \right)$	$\left|1\right.\rangle$
q[1]	0	$\left(\left|0\right.\rangle ,\left|1\right.\rangle \right)$	0	$\left(\left|0\right.\rangle ,\left|1\right.\rangle \right)$	$\left|0\right.\rangle$
q[2]	1	$\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$	0	$\left(\left|0\right.\rangle ,\left|1\right.\rangle \right)$	$\left|1\right.\rangle$
q[3]	0	$\left(\left|0\right.\rangle ,\left|1\right.\rangle \right)$	0	$\left(\left|0\right.\rangle ,\left|1\right.\rangle \right)$	$\left|0\right.\rangle$
q[4]	1	$\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$	1	$\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$	$\left|0\right.\rangle$
q[5]	0	$\left(\left|0\right.\rangle ,\left|1\right.\rangle \right)$	1	$\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$	$\left|+\right.\rangle$
q[6]	1	$\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$	1	$\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$	$\left|0\right.\rangle$
q[7]	0	$\left(\left|0\right.\rangle ,\left|1\right.\rangle \right)$	1	$\left(\left|+\right.\rangle ,\left|-\right.\rangle \right)$	$\left|+\right.\rangle$

presents the values for the LSBs of these pixels for Alice with her encoding basis, Bob’s LSBs, and his encoding basis, all together with the expected result.

Once the circuit has been created, the server measures the states, analyzes the results, and then sends Alice and Bob the positions of the qubits where the result is different from $\left|0\right.\rangle$—in the presented example, this would mean qubits with indexes 0, 2, 5, and 7 (see the final column in Table 2). Moreover, another way of interpreting the simulation results from the presented circuits is to notice the fact that whenever the last qubit is always in the $\left|0\right.\rangle$ state (that means that both Alice and Bob are measured on the same basis), then that qubit is not selected by the server. The generated key, $\left|1\right.\rangle$ $\left|1\right.\rangle$ $\left|+\right.\rangle$ $\left|+\right.\rangle$, can be further used by both parties as needed; more pixels from the image can be processed as described above and, for example, this key can be used to further encode communication using a symmetrical cryptographical algorithm.

4.2. Mathematical Interpretation

We now describe the core operations performed by the server in creating the quantum circuits from a mathematical perspective. For the circuits in Figure 4, Figure 5, Figure 6, Figure 7, Figure 8, Figure 9, Figure 10 and Figure 11, all qubits are initially set in the $\left|0\right.\rangle$ state. This is followed by setting all the position qubits in superposition, and at this point, we can write:

$$H\left(q{p}_i\right)=\frac{1}{\sqrt{2}}\left(\left|0\right.\rangle +\left|1\right.\rangle \right), \mathrm{for} i=\overline{0,5}.$$

This is followed by a layer of NOT gates, in order to match the desired position of the pixel in the image, which will be applied again, at the end of the representation for the current pixel (specific to the NEQR representation). The auxiliary qubits ($an{c}_i$, for $i=\overline{0.4}$) are used, in order to create the link between the desired position and a qubit (the final ancilla qubit, $an{c}_4$) that will be then set to the $\left|1\right.\rangle$ state. The state of this qubit (which is also initially $\left|0\right.\rangle$) should be interpreted as follows:

$$\begin{gathered} \left|an{c}_4\right.\rangle =\left|an{c}_0\right.\rangle \wedge \left|an{c}_1\right.\rangle \wedge \left|an{c}_2\right.\rangle \\ \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em} =\left|q{p}_5\right.\rangle \wedge \left|q{p}_4\right.\rangle \wedge \left|q{p}_3\right.\rangle \wedge \left|q{p}_2\right.\rangle \wedge \left|q{p}_1\right.\rangle \wedge \left|q{p}_0\right.\rangle . \end{gathered}$$

The CNOT gates set the corresponding position qubits to the $\left|1\right.\rangle$ state, using this last ancilla qubit. This can be written as follows, for the qubits that match the bits of 1 in the binary representation of the gray level:

$$\left|q_{\mathrm{i}}\right.\rangle =\left|q_{\mathrm{i}}\right.\rangle \oplus \left|an{c}_4\right.\rangle .$$

The steganography component that is combined with the B92 protocol can be seen for the $q_0$ qubit (equivalent to the LSB in the classical representation). We will refer to $f$ as the function that is performed by the server on this qubit. Here, we can group the possible choices into two main categories:

• The first scenario is when both Alice and Bob choose the same value for their LSB. If both of them set their LSB to 0, the server adds no gate and then the state of the qubit can be expressed as applying an identity gate:

  $$f\left(q_0\right)=I\left(q_0\right)=q_0=\left|0\right.\rangle ;$$

If both Alice and Bob set their LSB to 1, we will arrive at the same result; the server adds two Hadamard gates (one for each party), and the state of the qubit can be expressed as follows:

$$\begin{gathered} f\left(q_0\right)=H\left(H\left(q_0\right)\right)=H\left(\frac{1}{\sqrt{2}}\left(\left|0\right.\rangle +\left|1\right.\rangle \right)\right) \\ \hspace{1em}=\frac{1}{2}\left(\left|0\right.\rangle +\left|1\right.\rangle +\left|0\right.\rangle -\left|1\right.\rangle \right)=\left|0\right.\rangle ; \end{gathered}$$

2.

The second scenario is when only a single entity sets the LSB value to 1, and the other one sets it to 0. In this case, the state of the $q_0$ qubit can be written as follows, with the action of a single Hadamard gate:

$$f\left(q_0\right)=H\left(q_0\right)=\frac{1}{\sqrt{2}}\left(\left|0\right.\rangle +\left|1\right.\rangle \right)=\left|+\right.\rangle .$$

The measurement results clearly indicate that, for the first scenario, we obtain the $\left|0\right.\rangle$ state for the $q_0$ qubit; the results where the $an{c}_4$ qubit is in the $\left|1\right.\rangle$ state are the ones of interest (see the probability histograms from Figure 5, Figure 7, Figure 8 and Figure 10). In the second case, we obtain equal probabilities for the state of the $q_0$ qubit, which is interpreted by the server as the $\left|+\right.\rangle$ state (see the probability histograms from Figure 4, Figure 6, Figure 9 and Figure 11).

5. Discussion and Conclusions

The proposed paper describes the manner in which a shared grayscale image can be used to deliver a secret message, using the encoding idea from the B92 protocol. The algorithm that presents the method of obtaining the visually hidden string is parameterized—there is a group of options regarding encoding and position, which can be extended for different scenarios; the scheme also requires a server, used for the safe communication between the two parties. The concept unifies one of the quantum image representation techniques with steganography and a secure quantum communication protocol, thus presenting a bridge between various fields, suggesting a way that could perhaps change the perspective of quantum communication used alongside image processing.

The key points of the paper are:

• A new quantum steganography method is presented, combining some of the ideas from various subfields of quantum information processing;
• An implementation of the circuit representing the pixel values of the sender and receiver is described, along with their chosen bases for encoding information;
• The server is introduced as a third entity that can assist in the communication between the two parties, using the already established classically secured protocols. In the presented article, the server helps to convert the classical images to their quantum measurement basis in the quantum representation, but as a future concept, it could act directly as a qubit sharing entity.