Steganographer Identification

TL;DR

This paper reviews the Steganographer Identification Problem (SIP), focusing on unsupervised learning approaches to identify guilty actors in complex scenarios involving multiple digital objects and steganography.

Contribution

It provides a comprehensive tutorial on SIP, covering foundational concepts and advanced methodologies, highlighting current challenges and solutions in media steganography.

Findings

Unsupervised learning effectively identifies guilty actors in SIP.

Clustering and outlier detection are key techniques in SIP.

Existing methods perform well with non-adaptive steganography.

Abstract

Conventional steganalysis detects the presence of steganography within single objects. In the real-world, we may face a complex scenario that one or some of multiple users called actors are guilty of using steganography, which is typically defined as the Steganographer Identification Problem (SIP). One might use the conventional steganalysis algorithms to separate stego objects from cover objects and then identify the guilty actors. However, the guilty actors may be lost due to a number of false alarms. To deal with the SIP, most of the state-of-the-arts use unsupervised learning based approaches. In their solutions, each actor holds multiple digital objects, from which a set of feature vectors can be extracted. The well-defined distances between these feature sets are determined to measure the similarity between the corresponding actors. By applying clustering or outlier detection, the most suspicious actor(s) will be judged as the steganographer(s). Though the SIP needs further study, the existing works have good ability to identify the steganographer(s) when non-adaptive steganographic embedding was applied. In this chapter, we will present foundational concepts and review advanced methodologies in SIP. This chapter is self-contained and intended as a tutorial introducing the SIP in the context of media steganography.

Tables

Table 1. Table 1: Confusion matrix for identifying one guilty actor: 0.25 bpnc, 25%.

	Identified actor
Guilty actor	A	B	C	D	E	F	G
A	100	0	0	0	0	0	0
B	0	100	0	0	0	0	0
C	0	0	100	0	0	0	0
D	0	1	5	94	0	0	0
E	0	9	7	0	84	0	0
F	0	9	14	0	0	77	0
G	0	16	7	0	0	0	77

Table 2. Table 2: Confusion matrix for identifying one guilty actor: 0.3 bpnc, 30%.

	Identified actor
Guilty actor	A	B	C	D	E	F	G
A	100	0	0	0	0	0	0
B	0	100	0	0	0	0	0
C	0	0	100	0	0	0	0
D	0	0	0	100	0	0	0
E	0	0	0	0	100	0	0
F	0	0	1	0	0	99	0
G	0	0	0	0	0	0	100

Table 3. Table 3: Overall accuracy due to different parameter settings.

			Guilty actor s proportion of
			stego images @ payload per image
MMD	Cluster	$m$	10% @	30% @	50% @	70% @
kernel	linkage		0.1 bpnc	0.3 bpnc	0.5 bpnc	0.7 bpnc
Linear	Single	200	21.3%	100.0%	100.0%	100.0%
Linear	Single	100	18.0%	100.0%	100.0%	100.0%
Linear	Single	50	17.7%	99.9%	100.0%	100.0%
Linear	Single	20	14.1%	96.7%	100.0%	100.0%
Linear	Single	10	15.9%	86.4%	99.9%	100.0%
Linear	Centroid	200	17.0%	100.0%	100.0%	100.0%
Linear	Centroid	100	16.6%	100.0%	100.0%	100.0%
Linear	Centroid	50	16.3%	100.0%	100.0%	100.0%
Linear	Centroid	20	13.4%	97.0%	100.0%	100.0%
Linear	Centroid	10	15.4%	87.1%	99.9%	100.0%
Linear	Average	200	17.0%	100.0%	100.0%	100.0%
Linear	Average	100	16.4%	100.0%	100.0%	100.0%
Linear	Average	50	15.7%	100.0%	100.0%	100.0%
Linear	Average	20	14.3%	97.0%	100.0%	100.0%
Linear	Average	10	16.6%	87.1%	99.9%	100.0%
Linear	Complete	200	15.4%	100.0%	100.0%	100.0%
Linear	Complete	100	14.4%	100.0%	100.0%	100.0%
Linear	Complete	50	13.9%	99.3%	100.0%	100.0%
Linear	Complete	20	15.6%	94.9%	100.0%	100.0%
Linear	Complete	10	16.6%	84.0%	99.9%	100.0%
Gaussian	Centroid	200	14.0%	92.0%	100.0%	100.0%
Gaussian	Centroid	100	13.7%	87.4%	100.0%	100.0%
Gaussian	Centroid	50	12.6%	76.1%	100.0%	100.0%
Gaussian	Centroid	20	12.9%	60.1%	99.7%	100.0%
Gaussian	Centroid	10	15.3%	40.9%	98.4%	100.0%

Equations

$$\{\begin{array}{c}\begin{array}{rl}\text{Y}=& 0.299\text{R}+0.587\text{G}+0.114\text{B},\\ {\text{C}}_{\text{B}}=& 0.564(\text{B}-\text{Y}),\\ {\text{C}}_{\text{R}}=& 0.713(\text{R}-\text{Y}).\end{array}\end{array}$$

$$F(u,v)=\frac{1}{4}C(u)C(v)\sum _{x=0}^7\sum _{y=0}^{7}f(x,y)\text{cos}\frac{(2x+1)u\pi }{16}\text{cos}\frac{(2y+1)v\pi }{16},$$

$$f(x,y)=\frac{1}{4}\sum _{u=0}^7\sum _{v=0}^{7}C(u)C(v)F(u,v)\text{cos}\frac{(2x+1)u\pi }{16}\text{cos}\frac{(2y+1)v\pi }{16},$$

$$\begin{array}{rl}& \frac{{\sum }_{i,j=1}^8{\sum }_{k=1}^{|{\text{I}}_r|-1}|d_{i,j}({\text{I}}_r(k))-d_{i,j}({\text{I}}_r(k+1))|}{|{\text{I}}_r|+|{\text{I}}_c|}+\\ & \frac{{\sum }_{i,j=1}^8{\sum }_{k=1}^{|{\text{I}}_c|-1}|d_{i,j}({\text{I}}_c(k))-d_{i,j}({\text{I}}_c(k+1))|}{|{\text{I}}_r|+|{\text{I}}_c|},\end{array}$$

$$B_{\alpha }=\frac{{\sum }_{i=1}^{\lfloor (M-1)/8\rfloor }{\sum }_{j=1}^N|{\text{c}}_{8i,j}-{\text{c}}_{8i+1,j}{|}^{\alpha }+{\sum }_{j=1}^{\lfloor (N-1)/8\rfloor }{\sum }_{i=1}^M|{\text{c}}_{i,8j}-{\text{c}}_{i,8j+1}{|}^{\alpha }}{N\lfloor (M-1)/8\rfloor +M\lfloor (N-1)/8\rfloor },$$

$$\begin{array}{rl}& \frac{{\sum }_{k=1}^{|{\text{I}}_r-1|}\delta (s,d_{i,j}({\text{I}}_r(k)))\delta (t,d_{i,j}({\text{I}}_r(k+1)))}{|{\text{I}}_r|+|{\text{I}}_c|}+\\ & \frac{{\sum }_{k=1}^{|{\text{I}}_c|-1}\delta (s,d_{i,j}({\text{I}}_c(k)))\delta (t,d_{i,j}({\text{I}}_c(k+1)))}{|{\text{I}}_r|+|{\text{I}}_c|}.\end{array}$$

$${\text{H}}_l(J_1)-{\text{H}}_l(J_2),l\in \{-5,-4,...,5\},$$

$${\text{h}}_l^{i,j}(J_1)-{\text{h}}_l^{i,j}(J_2),l\in \{-5,-4,...,5\}.$$

$${\text{g}}_{i,j}^d(J_1)-{\text{g}}_{i,j}^d(J_2),$$

$${\text{C}}_{s,t}(J_1)-{\text{C}}_{s,t}(J_2),(s,t)\in [-2,2]\times [-2,2].$$

$$\{\begin{array}{c}\begin{array}{rl}{F}_h(u,v)& =F(u,v)-F(u+1,v),\\ F_v(u,v)& =F(u,v)-F(u,v+1),\\ F_d(u,v)& =F(u,v)-F(u+1,v+1),\\ F_m(u,v)& =F(u+1,v)-F(u,v+1).\end{array}\end{array}$$

$$\{\begin{array}{c}\begin{array}{rl}{\text{M}}_h(i,j)& =\frac{{\sum }_{u,v}\delta (F_h(u,v)=i,F_h(u+1,v)=j)}{{\sum }_{u,v}\delta (F_h(u,v)=i)},\\ {\text{M}}_v(i,j)& =\frac{{\sum }_{u,v}\delta (F_v(u,v)=i,F_v(u,v+1)=j)}{{\sum }_{u,v}\delta (F_v(u,v)=i)},\\ {\text{M}}_d(i,j)& =\frac{{\sum }_{u,v}\delta (F_d(u,v)=i,F_d(u+1,v+1)=j)}{{\sum }_{u,v}\delta (F_d(u,v)=i)},\\ {\text{M}}_m(i,j)& =\frac{{\sum }_{u,v}\delta (F_m(u+1,v)=i,F_m(u,v+1)=j)}{{\sum }_{u,v}\delta (F_m(u,v)=i)}.\end{array}\end{array}$$

$$\frac{{\sum }_{m,n,u,v}\delta (|c_{m,n}(u,v)|=x,|c_{m,n}(u,v+1)|=y,|c_{m,n}(u,v+2)|=z)}{48MN},$$

$$\frac{{\sum }_{m,n,u,v}\delta (|c_{m,n}(u,v)|=x,|c_{m,n}(u+1,v)|=y,|c_{m,n}(u+2,v)|=z)}{48MN},$$

$$\frac{{\sum }_{m,n,u,v}\delta (|c_{m,n}(u,v)|=x,|c_{m,n}(u+1,v+1)|=y,|c_{m,n}(u+2,v+2)|=z)}{36MN}.$$

$$F_{ia}(x,y,z)=\frac{1}{3}\{F_{ia}^{(h)}(x,y,z)+F_{ia}^{(v)}(x,y,z)+F_{ia}^{(d)}(x,y,z)\},$$

$$\frac{{\sum }_{m,n,u,v}\delta (|c_{m,n}(u,v)|=x,|c_{m,n+1}(u,v)|=y,|c_{m,n+2}(u,v)|=z)}{64M(N-2)},$$

$$\frac{{\sum }_{m,n,u,v}\delta (|c_{m,n}(u,v)|=x,|c_{m+1,n}(u,v)|=y,|c_{m+2,n}(u,v)|=z)}{64(M-2)N},$$

$$\frac{{\sum }_{m,n,u,v}\delta (|c_{m,n}(u,v)|=x,|c_{m+1,n+1}(u,v)|=y,|c_{m+2,n+2}(u,v)|=z)}{64(M-2)(N-2)}.$$

$$F_{ir}(x,y,z)=\frac{1}{3}\{F_{ir}^{(h)}(x,y,z)+F_{ir}^{(v)}(x,y,z)+F_{ir}^{(d)}(x,y,z)\},$$

$$D_{\text{SL}}=\underset{x\in X,y\in Y}{\min }d(x,y).$$

$$D_{\text{CL}}=\underset{x\in X,y\in Y}{\max }d(x,y).$$

$$D_{\text{CEN}}=\frac{1}{|X|\cdot |Y|}\sum _{x\in X}\sum _{y\in Y}d(x,y),$$

$$D_{\text{AL}}=\frac{1}{|X\cup Y{|}^2-|X\cup Y|}\underset{u,v\in X\cup Y,u\ne v}{\sum \sum }d(u,v).$$

$${\text{LRD}}_k(p)=\frac{|N_k(p)|}{{\sum }_{o\in N_k(p)}{r}_k(p,o)}.$$

$${\text{LOF}}_k(p)=\frac{1}{|N_k(p)|}\sum _{o\in N_k(p)}\frac{{\text{LRD}}_k(o)}{{\text{LRD}}_k(p)}.$$

$$\text{MMD}[\mathcal{F},p,q]=\underset{f\in \mathcal{F}}{\sup }{\mathbb{E}}_{\text{x}\sim p(\text{x})}f(\text{x})-{\mathbb{E}}_{\text{y}\sim q(\text{y})}f(\text{y}),$$

$$\text{MMD}[\mathcal{F},X,Y]=\underset{f\in \mathcal{F}}{\sup }\frac{1}{|X|}\sum _{\text{x}\in X}f(\text{x})-\frac{1}{|Y|}\sum _{\text{y}\in Y}f(\text{y}).$$

$${\text{MMD}}^2[\mathcal{F},p,q]={\Vert {\mathbb{E}}_{\text{x}\sim p(\text{x})}\varphi (\text{x})-{\mathbb{E}}_{\text{y}\sim q(\text{y})}\varphi (\text{y})\Vert }_{\mathcal{H}}^2.$$

$$\text{MMD}[\mathcal{F},X,Y]={\left(\frac{1}{|X{|}^2-|X|}\sum _{i\ne j}h[i,j]\right)}^{1/2},$$

Full text

\Frontmatter

\Mainmatter

Chapter 0 Steganographer Identification

[1]Hanzhou Wu111This invited chapter draft is intended as a tutorial introducing the steganographer identification problem in the context of media steganography so that a reader could easily master the basics and key methodologies of SIP. Our focuses are the general technical frameworks, ensemble methods, and feature reduction techniques. No matter what the final decision of this chapter draft will be, if you find any descriptive or technical errors, please do not hesitate to contact me. Errors will be corrected in the revised version. Thank you so much.

[1]; https://sites.google.com/view/hzwu

\titlemark

Steganographer Identification \chaptermarkSteganographer Identification

\MaxmMiniTocnum

A.13.3.3

\minitoc

\makechaptertitle

1 Introduction

Steganography [1] hides from untrusted parties the fact that any secret is being communicated. It can be realized by embedding the secret message into an innocent object (e.g., digital image) called cover. The resultant object called stego will be sent to the trusted receiver who can perfectly retrieve the secret message from the stego according to a key. A most important requirement for any secure steganographic system is that it should be impossible for an eavesdropper to distinguish between ordinary objects and objects that contain secret information. From the perspective of the opponent, steganalysis reveals the presence of hidden messages. The objective of steganography and steganalysis can be described as follows. As shown in Figure 1.1, Alice wants to send message m into a randomly sampled genuine cover x. She utilizes a key to drive the embedding procedure to generate the stego y, which is sent through the insecure channel and inspected by Eve’s detection algorithm, the steganalyzer. Eve has to gather evidence about the type of communication from a single output of the steganalyzer and decide whether or not to cut the communication channel. If Bob receives y, he extracts m with the key.

There are two common principles for designing steganographic systems [2]. One is model-preserving steganography, aiming to preserve the selected model of the cover source during data embedding, e.g., the histogram. The other one treats steganography as a rate-distortion optimization task. For a payload, we hope to minimize the data embedding distortion. In other words, we want to embed as many message bits as possible for a distortion. Current advanced steganographic algorithms first assign costs of changing individual elements based on their local neighborhood and then hide the payload using coding techniques with (near) minimal total embedding cost [3].

Steganalysis has been greatly developed as well. As shown in Figure 1.2, the contemporary approach to steganalysis involves three components. It extracts steganalytic features from objects; it supplies training sets of cover and stego objects; and it runs a machine learning algorithm (e.g., SVM) on the training data. This creates a decision function for novel objects, classifying them as cover or stego. Since steganography generally modifies noise-like components of the cover, advanced feature extractors aim to mine the statistical difference in high-frequency areas for detection.

In traditional steganalysis, each cover object is treated in isolation, which is implicit in the vast majority of the literature, e.g., they separate cover objects from stego objects, working on each object individually. However, such a restriction is unrealistic: In practice, we may face a complex scenario that multiple network actors send a set of media files while one or some of them are using steganography. To make matters even more complicated, an actor who is guilty of performing steganography will probably behave innocently some of the time, mixing the stego objects with genuine covers [4]. Therefore, any steganalyst will surely have to consider multiple actors, and each will transmit multiple objects, which is referred to as the Steganographer Identification Problem (SIP). One might use traditional steganalysis to find stegos and then identify the guilty actors. However, the guilty actors may be lost due to a number of false alarms. Because, most traditional steganalysis algorithms involve a binary classification algorithm, which has to be trained on large sets of covers and stegos. In practice, the cover source of the actors will not be identical to that used for training by the steganalyst, so as well as being computationally demanding the training itself becomes a possible source of error if an innocent actor is falsely accused because of training model mismatch [5, 6].

It therefore requires us to design reliable detectors for the aforementioned complex scenario. Fortunately, though the SIP needs further investment, there are some effective works reported in the literature. Figure 1.3 shows an example to identify the guilty actor from multiple actors by unsupervised learning. Each actor holds multiple images, from which multiple feature sets can be extracted. Each feature set can be regarded as a “point”. By using unsupervised learning based method such as clustering, the most suspicious point, i.e., feature set D, can be found out. Accordingly, Kim will be judged as the guilty actor. Following this line, in this chapter, we will introduce the foundational concepts and detail the methodologies of SIP. We hope this chapter could help readers to master both basic concepts and advanced technologies for SIP.

The structure of this chapter is organized as follows. In Section 1.2, we present the primary concepts and techniques. Then, in Section 1.3, we show two mainstream technical frameworks for SIP. In Section 1.4, we introduce the ensemble and dimensionality reduction techniques for improving identification performance. Finally, we conclude this chapter in Section 1.5.

2 Primary Concepts and Techniques

1 JPEG Compression

JPEG is a common method of lossy compression for digital images. The degree of compression can be adjusted, allowing a selectable tradeoff between storage size and image quality. Unless mentioned, we will use JPEG images as the covers for steganography throughout this chapter because JPEG image is one of the most popular type of cover over social networks. We here briefly review the JPEG compression procedure in JPEG images.

The JPEG compression algorithm is designed specifically for the human eye. It exploits the biological properties of human sight: we are more sensitive to the illuminocity of color, rather than the chromatric value of an image, and we are not particularly sensitive to high-frequency content in images. The encoding process of the JPEG compression algorithm has five main basic steps:

The representation of the colors in the image is converted from RGB to $\text{Y}\text{C}_{\text{B}}\text{C}_{\text{R}}$, having one luminance Y, and two chrominances $\text{C}_{\text{B}}$ and $\text{C}_{\text{R}}$. 2. 2.

The resolution of the chroma data is reduced. This reflects the fact that eyes are less sensitive to fine color details than to fine brightness details. 3. 3.

The image is split into blocks of $8\times 8$ pixels, and for each block, each of the Y, $\text{C}_{\text{B}}$, and $\text{C}_{\text{R}}$ data undergoes the discrete cosine transform (DCT). 4. 4.

The amplitudes of the frequency components are quantized. The quality setting of the encoder affects to what extent the resolution of each frequency component is reduced. The magnitudes of the high-frequency components are stored with a lower accuracy than the low-frequency components. 5. 5.

The resulting data for all $8\times 8$ blocks is further compressed with a lossless algorithm, a variant of Huffman encoding.

The decoding process reverses these steps, except the quantization because it is irreversible. Y, $\text{C}_{\text{B}}$, and $\text{C}_{\text{R}}$ can be determined as:

[TABLE]

For a pixel-block sized $8\times 8$, the DCT can be described as:

[TABLE]

[TABLE]

where $C(z)=1/\sqrt{2}$ for $z=0$; otherwise, $C(z)=1$. Here, $f(u,v)$ denotes the value at position $(u,v)$ to be transformed, and, $F(u,v)$ is the DCT coefficient.

Once DCT is finished, JPEG moves on to quantization, in which the less important DCT coefficients are wiped out. For quantization, we need a quantization table $T\in\mathbb{Z}^{8\times 8}$. After quantization, $F(u,v)$ will be updated as $\lfloor\frac{F(u,v)}{T(u,v)}\rfloor$.

2 JPEG Steganalysis Features

Each actor’s JPEG images are represented by low dimensional feature vectors. We call them as JPEG steganalysis features. In this section, we review two JPEG feature extractors since they will be used latter. However, it is always free for us to design other efficient feature extractors for JPEG steganalysis.

PEV-274 Features

T. Pevn$\acute{\text{y}}$ and J. Fridrich [7] merged the DCT features and Markov features to produce a 274-D feature vector called PEV-274 for JPEG steganalysis.

Let the luminance of a JPEG file be represented with a DCT coefficient array $d_{i,j}(k)$, $i,j=1,...,8$, $k=1,...,n_{B}$, where $d_{i,j}(k)$ denotes the $(i,j)$-th quantized DCT coefficient in the $k$-th block (there are $n_{B}$ blocks). Let H be the histogram of all $64\times n_{B}$ luminance DCT coefficients, i.e., $\textbf{H}=(H_{L},...,H_{R})$, where $L=\text{min}_{i,j,k}d_{i,j}(k)$ and $R=\text{max}_{i,j,k}d_{i,j}(k)$. Let $\textbf{h}^{i,j}=(h_{L}^{i,j},...,h_{R}^{i,j})$ be a histogram of coefficients for DCT mode $(i,j)$. Let the dual histograms with $8\times 8$ matrices be $\textbf{g}_{i,j}^{d}=\sum_{k=1}^{n_{B}}\delta(d,d_{i,j}(k))$, where $i,j=1,...,8$, $d=-5,...,5$, and $\delta(x,y)=1$ if $x=y$ and 0 otherwise. The inter-block dependency among DCT coefficients can be captured. First, we find the variation $V=$:

[TABLE]

where $\textbf{I}_{r}$ and $\textbf{I}_{c}$ denote the vectors of block indices $1,...,n_{B}$ while scanning the image by rows and by columns, respectively. Then, two scalars calculated from the decompressed JPEG image representing an integral measure of inter-block dependency over all DCT modes over the whole image are collected:

[TABLE]

where $M$ and $N$ are height and width, $\textbf{c}_{i,j}$ is the grayscale value of the decompressed JPEG image, $\alpha=1,2$. We can also collect calibrated co-occurrence features, e.g., $\textbf{C}_{0,0}(J_{1})-\textbf{C}_{0,0}(J_{2})$, where $\textbf{C}_{s,t}=\sum_{i,j=1}^{8}E_{i,j}$ and $E_{i,j}$ equals:

[TABLE]

$J_{1}$ is the stego image, and $J_{2}$ is its calibrated version. Calibration estimates macroscopic properties of the cover from the stego. During calibration, $J_{1}$ is decompressed to the spatial domain, cropped by a few pixels in two directions, and compressed again with the same quantization matrix as $J_{1}$. The newly obtained $J_{2}$ has the most macroscopic features similar to the original cover. This is because the cropped image is visually similar to the original image. Moreover, the cropping operation brings the $8\times 8$ DCT grid “out of sync” with the previous compression, which effectively suppresses the influence of the previous JPEG compression and the embedding changes.

The above analysis allows us to construct 193-D DCT features. In detail, we first collect 66-D histogram features, i.e.,

[TABLE]

and for all $(i,j)\in\mathcal{L}$ = $\{(1,2)$, $(2,1)$, $(3,1)$, $(2,2)$, $(1,3)\}$,

[TABLE]

For dual histograms $\textbf{g}^{d},d\in\{-5,-4,...,5\}$, we determine the difference of the 9 lowest AC modes, i.e.,

[TABLE]

where $(i,j)\in\{(2,1),(3,1),(4,1),(1,2),(2,2),(3,2),(1,3),(2,3),(1,4)\}$. It allows us to collect 99-D DCT features. For the co-occurrence matrix, the central elements in the range $[-2,2]\times[-2,2]$ are used, yielding to 25-D features

[TABLE]

By further collecting $V$, $B_{1}$, $B_{2}$, we have 193-D DCT features. The Markov feature set proposed in [8] models the differences between absolute values of neighboring DCT coefficients as a Markov process. The calculation starts by forming the matrix $F(u,v)$ of absolute values of DCT coefficients in the image. The DCT coefficients in $F(u,v)$ are arranged in the same way as pixels in the image by replacing each $8\times 8$ block of pixels with the corresponding block of DCT coefficients Four difference arrays can be calculated along four directions: horizontal, vertical, diagonal, and minor diagonal, i.e.,

[TABLE]

From these difference arrays, four transition probability matrices $\textbf{M}_{h}$, $\textbf{M}_{v}$, $\textbf{M}_{d}$, $\textbf{M}_{m}$ are constructed as:

[TABLE]

If the matrices are taken directly as features, the dimensionality would be too large. By using the central $[-4,4]$ portion of the matrices, the dimension is then $4\times 9^{2}=324$. Obviously, the above Markov features can be calibrated, i.e., $\textbf{M}^{(c)}=\textbf{M}(J_{1})-\textbf{M}(J_{2})$. The dimension of the calibrated Markov feature set, $\{\textbf{M}_{h}^{(c)},\textbf{M}_{v}^{(c)},\textbf{M}_{d}^{(c)},\textbf{M}_{m}^{(c)}\}$, remains the same as its original version. PEV-274 uses the average $\bar{\textbf{M}}=(\textbf{M}_{h}^{(c)}+\textbf{M}_{v}^{(c)}+\textbf{M}_{d}^{(c)}+\textbf{M}_{m}^{(c)})/4$, which has a dimension of 81. Accordingly, for PEV-274, the dimension is $193+81=274$.

LI-250 Features

Li et al. [9] proposed high-order joint features for SIP. The motivation is that, most JPEG steganographic methods would change the correlation of neighboring coefficients due to the modification of DCT coefficiants. Thus, Markov transition probability will be affected with the data embedding operation. However, Markov transition probabilities may be incapable of fully exploiting the changes in DCT coefficients and may not completely capture the neighboring joint relation. Thus, Li et al. developed a 250-D features, by employing joint density matrices, for pooled JPEG steganalysis. The high-order joint features are driven from high-order joint density matrices of DCT coefficients, which indicate the intra-block and inter-block dependencies of JPEG images. The features include two parts: one part is generated from mean joint density matrices of intra-block, while the other is derived from the mean joint density matrices of inter-block. The details of extracting the features are as follows.

Denoting the quantized DCT coefficients in the blocks of JPEG image as $c_{m,n}(u,v)$, where $m\in[1,M]$ and $n\in[1,N]$ are the indices of blocks, and $u$ and $v$ indicate the positions of coefficients in each block. The intra-block joint density matrices along horizontal, vertical, and diagonal directions, denoted by $F_{ia}^{(h)}(x,y,z)$, $F_{ia}^{(v)}(x,y,z)$, $F_{ia}^{(d)}(x,y,z)$, are calculated by:

[TABLE]

[TABLE]

[TABLE]

The intra-block joint features $F_{ia}(x,y,z)$ are then calculated by:

[TABLE]

where $x,y,z\in[0,4]$. Thus, the dimension of intra-block joint features is 125. Similarly, the inter-block second-order joint density matrices along the three directions, denoted by $F_{ir}^{(h)}(x,y,z)$, $F_{ir}^{(v)}(x,y,z)$, $F_{ir}^{(d)}(x,y,z)$, can be calculated respectively by:

[TABLE]

[TABLE]

[TABLE]

The inter-block joint features $F_{ir}(x,y,z)$ are calculated by

[TABLE]

where $x,y,z\in[0,4]$. Thus, the dimension of inter-block joint features is 125. By combining the intra-block features and the inter-block features, we can get 250-D high-order joint features, which will be used for SIP later.

3 Batch Steganography and Pooled Steganalysis

In SIP, each actor holds multiple digital objects. Normal actors take no action to their own digital objects. While, for a guilty actor, i.e., the steganographer, he distributes a secret payload into the objects held by himself. It involves the concept of batch steganography [4], which can be described as follows: given a total of $n$ cover objects, the steganographer hides data in $m\leq n$ of them and leaves the other covers alone. Obviously, to secure steganography, how to best spread payload between multiple covers is a critical problem to the steganographer. For a steganalysis expert, how to pool evidence from multiple objects of suspicion is a key topic, which is called pooled steganalysis [4]. The methods for SIP can be regarded as pooled steganalysis.

Recalling the goal of batch steganography: the steganographer wants to spread a message of length $L$ among images $(I_{1},I_{2},...,I_{n})$ with secure capacities $(c_{1},c_{2},...,c_{n})$ using a steganographic embedding algorithm for individual images. He needs to determine the message fragment lengths $(l_{1},l_{2},...,l_{n})$, with $L=\sum_{i=1}^{n}l_{i}$, to be embedded into the images. There are four common strategies reported in the literature [10]: max-greedy, max-random, linear and even. In the max-greedy strategy, the steganographer embeds the message into the fewest possible number of covers. Assuming that the images are ordered by capacity $c_{1}>c_{2}>...>c_{n}$, it leads to the following message lengths: $l_{i}=c_{i},\forall i\in[1,m-1]$, $l_{m}=L-\sum_{i=1}^{m-1}l_{i}$, and $l_{i}=0,\forall i\in[m+1,n]$. The max-random strategy is the same as max-greedy, except that the images to be embedded are chosen in a random order. In the linear strategy, the message is distributed into all images proportionately to their capacity, i.e., $l_{i}=\frac{c_{i}L}{\sum_{j=1}^{n}c_{j}}$. For the even strategy, the secret message is distributed evenly, i.e., $l_{i}=L/n$. The existing works [4, 11, 12] point that, for the steganographer, the optimal behaviour is likely to be extreme concentration of payload into as few covers as possible, or the opposite in which payload is spread as thinly as possible. However, these theoretical results could not be confirmed without practical pooled steganalyzers to test against.

The aforementioned strategies require the steganographer to estimate the capacities. Ker et al. [10] presented a method to estimating the maximum message length for each available image for practical steganography. They first query the implementation of an algorithm to provide an initial estimate of the maximum message length. This is done either by embedding a very short message into the given message, or asking for information about a given image. Once having an initial estimate, they try to embed a randomly string of this length. If the embedding fails, the estimate of the capacity is decreased by ten bytes and the procedure is repeated. Otherwise, they deem the current estimate of the capacity as the final. It is pointed that, the capacity for an image is actually not easy to be well-defined in terms of security. One may exploit steganalysis for estimating the secure capacity, rather than simply estimating the maximum embeddable payload as the capacity.

4 Agglomerative Clustering

The hierarchical cluster analysis [13] seeks to build a hierarchy of clusters, allowing us to partition a set of objects such that “similar” objects can be clustered. As a type of hierarchical cluster analysis, agglomerative clustering is such a “bottom-up” approach that each object starts in its own cluster, and pairs of clusters are merged as one moves up the hierarchy. As shown in Algorithm 1, the basic agglomerative clustering maintains an “active set” of clusters (initially, all objects are belonging to the active set) and at each stage the nearest two clusters are merged. When two clusters are merged, they are removed from the active set and their union is added to the active set. It iterates until there is only one cluster in the active set. The tree is formed by keeping track of which clusters were merged. All that is needed is a method to compute a distance between two clusters, for which there are a number of options. We introduce several distance measures below.

Let us write $d(x,y)$ for the distance between two objects $x$ and $y$, and $D(X,Y)$ for the distance between two clusters $X$ and $Y$. The single linkage uses the distance between the nearest points in the two clusters:

[TABLE]

The complete linkage uses the furthest points:

[TABLE]

The single linkage can cause long chains of clusters, whereas complete linkage prefers compact clusters; other agglomerative clustering algorithms are intermediate, including centroid clustering

[TABLE]

and average linkage

[TABLE]

The input to the basic agglomerative clustering is a distance matrix between objects. The output can be displayed in a dendrogram, a tree of the successive cluster agglomerations using “height” to indicate the distance between clusters being merged.

5 Local Outlier Factor

The local outlier factor (LOF) [14] is an outlier detection method by measuring the local deviation of a sample point with respect to its neighbours, which requires a distance measure $d:\mathcal{X}\times\mathcal{X}\mapsto\mathbb{R}$. Assuming that, we have a set of feature points $C$ (vectors). We expect to estimate the degree of outlying of the point $p\in C$. The LOF uses a parameter $k\in\mathbb{N}$, with $1<k<|C|$, specifying the number of nearest neighbors.

In LOF, the $k$-distance of $p$, denoted by $d_{k}(p)$, is defined as a distance between $p$ and $o\in C\setminus\{p\}$, such that:

• •

for at least $k$ points $o^{\prime}\in C\setminus\{p\}$, it holds $d(p,o^{\prime})\leq d_{k}(p)$, and

• •

for at most $k-1$ points $o^{\prime}\in C\setminus\{p\}$, it holds $d(p,o^{\prime})<d_{k}(p)$.

The $k$-neighborhood of $p$ is defined as $N_{k}(p)=\{o\in C|d(p,o)\leq d_{k}(p)\}$. Note that, the number of elements in the $k$-th neighborhood, i.e., $|N_{k}(p)|$, can be greater than $k$. The reachability distance of $p$ w.r.t. $o$ is defined as $r_{k}(p,o)=\text{max}\{d_{k}(o),d(p,o)\}$. The local reachability density of $p$ is defined as an inverse of the average reachability distance of $p$ to all points $o$ in its $k$-neighborhood, i.e.,

[TABLE]

The LOF method uses reachability distance to estimate density of the probability at point $p$. It also estimates the average density of the probability of all points in the $k$-neighborhood, $o\in N_{k}(p)$, and compares these quantities. The level of outlying is therefore adaptive with respect to the closest neighborhood. Thus, the LOF value of $p$ is finally defined as:

[TABLE]

The $\text{LOF}_{k}(p)$ captures degree to which $p$ can be called an outlier. A high value indicates that $p$ is an outlier, since its reachability density, $\text{LRD}_{k}(p)$, is smaller in comparison to the local reachability density of its neighbors.

6 Maximum Mean Discrepancy

In SIP, we need a measure of distance between two actors. Since each actor has a set of feature vectors, we have to design a distance measure for two sets of feature vectors. The maximum mean discrepancy (MMD) [15, 16, 17] has been empirically shown to be quite effective for distance measurement. It can be used for SIP. Given observations $X=\{\textbf{x}_{i}\}_{i=1}^{|X|}$ and $Y=\{\textbf{y}_{i}\}_{i=1}^{|Y|}$, which are i.i.d. drawn from $p(\textbf{x})$ and $q(\textbf{y})$ defined on $\mathbb{R}^{d}$, let $\mathcal{F}$ be a class of functions $f:\mathbb{R}^{d}\mapsto\mathbb{R}$, the MMD and its empirical estimate are:

[TABLE]

[TABLE]

Usually, $\mathcal{F}$ is selected as a unit ball in a universal RKHS $\mathcal{H}$ defined on compact metric space $\mathbb{R}^{d}$ with kernel $k(\cdot,\cdot)$ and feature mapping $\phi(\cdot)$. The Gaussian and Laplacian kernels are universal. It has been proven that,

[TABLE]

An unbiased estimate of MMD is:

[TABLE]

where $|X|=|Y|$ is assumed and

[TABLE]

For any two sets, we can use the unbiased estimate of MMD to measure their distance. However, it is noted that, when a set has only one feature vector, we cannot use MMD since its value always equals zero. In this case, one may use Euclidean metric, i.e., $d(\textbf{x},\textbf{y})=||\textbf{x}-\textbf{y}||_{2}$, or other metrics. A kernel function is required when to use MMD. There are choices for $k$. For example, the linear kernel which is simply a scalar product

[TABLE]

and the Gaussian kernel is defined as

[TABLE]

where $\gamma$ is a parameter. Typically, $\gamma$ is set to $\eta^{2}$, where $\eta$ is the median of the $L_{2}$-distance between features in the set of images being considered: this means that the exponents are, on average, close to -1.

3 General Frameworks

In this section, we review two general frameworks used in SIP. It can be said that, most of the present state-of-the-arts base on the two frameworks. Both are proposed by Ker et al., which can be found in references [5, 6, 18].

1 Clustering-based Detection

Suppose that, multiple actors each will transmit multiple objects, all of which have been intercepted. Each actor may use multiple sources of objects. For simplicity, we assume that, each actor has just one source of objects, but that these sources could be different from each other. For each actor, we compute the feature vectors from the objects held by this actor. We can think of this as many clouds of points in the feature space, one cloud for each actor. A guilty actor is one who using steganography in (some of) their transmitted objects. We aim to identify guilty actors if their clouds of feature vectors stand out, in some way, from the normal actors’.

Applying steganalysis to each object individually might be valuable, but it is likely that any guilty party could be lost in a crowd of false positives. If we use a trained model for the objects to be tested, it will produce the mismatching problem in practice. It is possible to perform clustering on the individual objects, which may provide little information. It inspires us to consider each actor’s objects as a whole to characterize their source. In this way, we are to cluster the actors, hoping to separate an innocent majority from a guilty minority. Here, clustering the actors is equivalent to clustering the clouds mentioned above. Each cloud consists of a set of feature vectors.

Thus, we combine the hierarchical clustering with the MMD distance measure for SIP. The distances between actors are defined as the MMD distance between the sets of feature vectors. If the features have been well-chosen so that the difference between actors’ sources is less than the difference between guilty and normal actors, the final agglomeration will be between two clusters, the normal and the guilty. Thus, we can extract a list of suspected guilty actors from the cluster dendrogram. As well as depending on the features, the accuracy of this method will also depend on the proportion of objects which guilty actors embed in, and the amount they embed. Such detector assumes that, the majority of actors is normal, and tries to identify guilty actors as an outlier cluster.

Pre-processing the directly extracted features is necessary to guarantee the accuracy of the detection method since the raw features have different scales. Feature normalization is a good choice and other preprocessing methods may be suitable as well such as principal component transformation. By normalization, we mean linear scaling of features such that each column of the data matrix $\widehat{\text{X}}$ has zero mean and unit variance. This means that

[TABLE]

and

[TABLE]

where $n$ is the number of actors, and $l$ for the number of objects held by each actor. The preprocessing enables the distance measure to be more meaningful and not significantly affected by noisy components.

Mathematically, let $A=\{a_{1},a_{2},...,a_{n}\}$ and $S(a_{i})=\{\textbf{I}_{1}^{(i)},\textbf{I}_{2}^{(i)},...,\textbf{I}_{m}^{(i)}\}$ respectively represent the actors and the objects held by actor $a_{i}$. Based on the aforementioned analysis, we describe the detailed steps for the (hierarchical) clustering based framework as follows.

For each actor $a_{i}$, $1\leq i\leq n$, with a well-designed feature extractor $\mathcal{E}_{\text{fea}}$, we extract the feature vectors from the objects in $S(a_{i})$, which is denoted by $F(a_{i})=\{\textbf{f}_{1}^{(i)},\textbf{f}_{2}^{(i)},...,\textbf{f}_{m}^{(i)}\}$. 2. 2.

For each actor $a_{i}$, $1\leq i\leq n$, normalizing $F(a_{i})$ by the above method. 3. 3.

For any two different actors $a_{i}$ and $a_{j}$, $1\leq i<j\leq n$, determine the MMD distance between normalized $F(a_{i})$ and normalized $F(a_{j})$. 4. 4.

Apply hierarchical clustering, and collect two clusters $\mathcal{C}_{1}$ and $\mathcal{C}_{2}$ at the final stage of merging. The actors belonging to the cluster with a smaller size are considered as the guilty actors.

Assuming that, we want to find $k\leq|\mathcal{C}_{1}|+|\mathcal{C}_{2}|$ suspicious actors, and $|\mathcal{C}_{1}|\leq|\mathcal{C}_{2}|$. If $k\leq|\mathcal{C}_{1}|$, we randomly choose $k$ actors from $\mathcal{C}_{1}$ as the guilty actors. Otherwise, all actors in $\mathcal{C}_{1}$ and $k-|\mathcal{C}_{1}|$ randomly-selected actors in $\mathcal{C}_{2}$ are judged as guilty ones. For better understanding, we take Figure 1.4 for explanation. In Figure 1.4, the above means MDS representation of actors, and the below shows cluster dendrograms, from which the final two clusters are encircled in the MDS plot. The left example implies $\mathcal{C}_{1}=\{$C$\}$ and $\mathcal{C}_{2}=\{$A, B, D, E, F, G$\}$. For the right example, we have $\mathcal{C}_{1}=\{$A, G$\}$ and $\mathcal{C}_{2}=\{$B, C, D, E, F$\}$. Suppose that, there has only one guilty actor. Then, for the left example, C will be judged as the suspicious actor. For the right example, either A or G will be judged as the steganographer. If there are three guilty actors, for the right example, $\{$A, G$\}$ and an actor randomly chosen from $\mathcal{C}_{2}$ can be selected out as the guilty actors.

2 Outlier-based Detection

The advantage of the hierarchical clustering based framework is that, by pooling objects from each actor together, the method improves the signal-to-noise ratio compared with working on individual objects. This leads to better accuracy in the identification of guilty actor. The rationale for using a clustering algorithm was that the group of guilty actors should form a distinct cluster, that would be well separated from the normal actors. In reality, differences in actors’ cover sources means that there is already variation in feature vectors between difference actors. The steganographic embedding may exhibit itself by a shift in the feature vectors in some direction(s). Consequently, the guilty actors could be represented by outliers, and thus allows us to switch our attention from clustering to outlier detection.

A lot of outlier detection methods can be found in the literature. The local outlier factor (LOF) method would be a good choice as: (a) it requires only the pairwise distances between points, (b) it is not tied to any particular application domain, (c) it directly provides a measure of how much an outlier each point is, and (d) it relies on single hyper-parameter. We use LOF for detection here. However, we point out that, it is always free for us to apply any effective outlier detection method for SIP.

We have introduced the concept of LOF in the previous section. Here, we directly present the pseudo-code of using LOF for SIP, which is shown in Algorithm 2. It is seen that, the steps are quite similar to that of the hierarchical clustering based framework. The LOF method does not provide a threshold, above which the element should be considered as an outlier. Such method has an advantage. Namely, the LOF values do not depend on the absolute values of distances, i.e., it is scale invariant. It is worth mentioning that, by switching to outlier detection, we have overcome another shortcoming of the clustering approach, which was the lack of any direct measure of “being an outlier”. If we know that we want to identify a single guilty, we can take the one with the largest LOF value; if we want to identify a short list of the $k$ most suspicious actors, we can choose those with top-$k$ LOF values.

3 Performance Evaluation and Analysis

We report experimental results in [5, 18] for performance analysis.

Clustering-based Detection

Suppose that, there are $n$ actors, each of whom has $m$ images, and we want to identify a single guilty actor from them. The actors are simulated by images taken from $n$ different cameras, all are JPEG compressed with an identical quality factor (QF). nsF5 [19] is used as the steganographic algorithm, which is an improved version of F5 [20]. F5 is a steganographic algorithm that aims to preserve the shape of the histogram of quantized DCT coefficients, making it similar to that of the cover image. The message is embedded by changing the absolute values of DCT coefficients toward zero. F5 is also the first algorithm to use matrix embedding, which is a coding scheme that increases embedding efficiency measured by the number of bits embedded per embedding change. As its variant, nsF5 uses the same type of embedding changes as F5. To avoid introducing more zeros, however, nsF5 uses wet paper codes [21, 22] with improved efficiency.

Each image is represented by a 274-D feature vector called PEV-274, designed for JPEG steganalysis and previously shown to be effective against nsF5. However, it is admitted that, nsF5 is detectable by modern steganalysis features. The hierarchical clustering technique with MMD distance between actors is used. The expectation is that the final agglomeration should be between one guilty actor and a cluster of $n-1$ normal actors. It is pointed that, there is no training in the paradigm, and it does not assume any knowledge of the actors’ cameras or the embedding algorithm.

There are $n=7$ actors sending JPEG images. Each actor converts the RAW photos to JPEG QF=80 before transmitting them. Each actor uses images of a constant size (the default resolution of the camera), but the image size does vary from actor to actor. Tables 1.1 and 1.2 show the confusion matrices for the identification of one guilty actor, with each experiment repeated 100 times per guilty actor. Each actor transmits $m=50$ JPEG images: Table 1.1, the guilty actor embeds 0.25 bits per non-zero coefficient (bpnc) in 25% of his images; Table 1.2, the guilty actor embeds 0.3 bpnc in 30% of his images. The single linkage and linear MMD are used here. The identification of the guilty party is performed by cutting the dendrogram at the final agglomeration, which has been described previously. It can be observed that, the overall accuracy are 90.3% and 99.9%, respectively. Performance falls of sharply for smaller payloads since the guilty actors fade into the normal cluster and they cannot be identified accurately.

Experiments are conducted with both linear and Gaussian MMD. Table 1.3 shows the experimental results due to different parameter settings. It can be found that, the clustering based on linear MMD worked better than that based on Gaussian MMD. Also, the choice of agglomeration algorithm did not make a substantial difference. As expected, there is a dependency on $m$: more evidence allows the detector to make more accurate detection from smaller payloads. When $m=200$, the linear MMD combined with any linkage achieved perfectly accurate detection of the guilty parity with payloads as small as 0.3 bpnc embedded in only 30% of the images.

Outlier-based Detection

Compared to clustering-based detection, outlier-based detection allows us to consider up to thousands actors each transmitting up to hundreds images. In [18], in each experiment, a randomly selected subset of 4000 actors and 200 images for each actor was used. The images were obtained from a social network site, which automatically resized large images, to approximately 1Mpix, and then JPEG compressed with QF = 85, at the time of crawling. Exactly one guilty actor was simulated by nsF5. Four different embedding strategies, i.e., max-greedy, max-random, linear and even, were used to insert $Lp$ bits to the images held by the guilty actor. $L$ is the total number of non-zero coefficients in the images. $p$ is the number of bits per non-zero coefficient. The PEV-274 features were extracted from the $nm$ JPEG images, and then normalized. The MMD distance between each pair of actors can be then determined. Finally, the LOF detection method was applied to compute the LOF score for each actor, which allowed us to identify the most suspicious actor that will be judged as the guilty actor.

For each combination of parameters, each experiment was repeated 500 times with a different selection of actors and guilty actor. The average rank of the guilty actor was used as a benchmark to reflect how well the guilty actor was identified. An average rank of one corresponds to perfect detection, i.e., the guilty actor is always ranked most suspicious. And, an average rank of $\frac{n+1}{2}$ corresponds to random guessing. We do not expect a universal, unsupervised detector to achieve perfect accuracy, but instead hope that, it provides intelligence by ranking a truly guilty actor among the top 10% of all actors. In addition, for the MMD distance, the centroid ‘kernel’ (a variant of linear kernel, please refer to the Appendix of [18]) was used. And, for the LOF detection, a parameter $k$ was set to 10. Figure 1.5 show the detection performance due to different parameters. It can be observed that, the max-greedy strategy is the most secure for the embedder: the average rank of the guilty actor is higher in all payloads. The second most secure strategy is max-random. The linear strategy is next and even is the most insecure. The reason that the max-greedy/max-random strategy is more secure than linear/even has been explained in detail in [10]. In brief, this effect is caused by whitening the features in the pre-processing stage. Overall, with relatively large payloads, the LOF method achieves efficient detection results.

4 Ensemble and Dimensionality Reduction

1 Clustering Ensemble

The clustering ensemble method combines the detection results from multiple clustering sub-models. As shown in Figure 1.6, the clustering ensemble framework is comprised of three parts: preprocessing, feature extraction, and clustering ensemble. The preprocessing procedure requires us to analyze the characteristics of the steganographic algorithm so that those sensitive components concealing the steganographic traces can be separated out from the stego. The preprocessing could be cropping, high-pass filtering, and other operations that can improve the statistical discriminability between the steganographic noise and the cover content. It can be said that, the goal of preprocessing is to enlarge the “signal-to-noise” ratio.

After preprocessing, we extract steganalysis features from the preprocessed objects, which reduces the preprocessed objects to vectors with a small dimension. We use $T$ clustering sub-models $\{C_{1},C_{2},...,C_{T}\}$ for clustering ensemble. For each sub-model $C_{i}$, we can directly apply the hierarchical clustering method, by which we can collect suspicious actor(s) that will be judged as the steganographer candidate(s). By merging the results from these sub-models, the index value(s) indicating the most suspicious actor(s) that will be chosen as the steganographer(s), can be determined.

For better understanding, we review Li et al.’s work [9], which is a related work exploiting clustering ensemble for SIP. In their work, the images held by actors are randomly cropped with smaller size to build actor subsets. Then, the LI-250 features mentioned in the aforementioned section are extracted from these actor subsets. After performing the agglomerative clustering in the (normalized) feature space, a most suspicious actor can be separated from the innocent ones. By repeating these steps, multiple decisions are made, and the final guilty actor can be identified by majority voting. It is mentioned that, in Li et al.’s work, the clustering operation is slightly different from the above basic agglomerative clustering algorithm, and they use Euclidean distance for two feature vectors. We detail the algorithm below.

Denote a set of $n$ actors as $\{A_{1},A_{2},...,A_{n}\}$, which include one guilty actor and $n-1$ normal (innocent) actors, each of whom transmits $m$ JPEG images. Clustering ensemble is used to identify the steganographer according to the following steps.

Denote the image sets of $n$ actors as $\{I_{1},I_{2},...,I_{n}\}$. Each $I_{i}~{}(1\leq i\leq n)$ contains $m$ JPEG images of size $M\times N$. Randomly crop each JPEG image in $I_{i}~{}(1\leq i\leq n)$ to size $m^{\prime}\times n^{\prime}~{}(m^{\prime}<M,n^{\prime}<N)$. The cropped images consist of $n$ subsets $I_{1}^{\prime},I_{2}^{\prime},...,I_{n}^{\prime}$, where $I_{i}^{\prime}~{}(1\leq i\leq n)$ includes $m$ JPEG images of size $m^{\prime}\times n^{\prime}$. 2. 2.

For each image subset $I_{i}^{\prime}~{}(1\leq i\leq n)$, extract the LI-250 features to form feature sets $F_{i}~{}(1\leq i\leq n)$, where $F_{i}=(f_{i}^{(1)},f_{i}^{(2)},...,f_{i}^{(m)})$ and each $f_{i}^{(j)}$ represents a 250-D feature vector. Notice that, each $F_{i}$ is associated with a second subscript $j~{}(1\leq j\leq T)$, i.e., $F_{i,j}$, to denote $F_{i}$ used in the $j$-th clustering sub-model since we have $T$ sub-models. 3. 3.

Normalize the feature sets $\{F_{1},F_{2},...,F_{n}\}$ such that every column of feature matrix has zero mean and unit variance. Then, the distance between different pairs of feature sets can be calculated with

[TABLE]

where $d(f_{i}^{(p)},f_{j}^{(q)})$ represents the Euclidean distance between the two feature vectors. 4. 4.

Perform hierarchical clustering with the above distance measure. First, two actors with the minimum distance are combined into a new cluster, denoted by $\mathcal{X}$, and the remaining actors are in a set denoted by $\mathcal{Y}$. We repeat to select an actor from $\mathcal{Y}$ and add the selected actor into $\mathcal{X}$ until only one actor is left in $\mathcal{Y}$. At each selection step, the actor $Y\in\mathcal{Y}$ who has the smallest distance to $\mathcal{X}$ is selected, where the distance between an actor $Y\in\mathcal{Y}$ and a cluster $\mathcal{X}$ is defined as:

[TABLE]

The last remaining actor in $\mathcal{Y}$ is considered a suspicious actor. 5. 5.

Repeat Steps 1-4 for $T$ times. Each time, we identify a suspicious actor, denoted by $C_{i},~{}i=1,2,...,T$. By majority voting with $T$ sub-models, the actor who is identified as suspicious the most frequently is determined as the final culprit. When there is a tie, randomly select one to break the tie.

The detection performance is evaluated by the overall identification accuracy rate, calculated as the ratio between the number of correctly detected steganographic actors and the selected total number of steganographic actors. In Li et al’s method, the original images are cropped to images with a smaller size. Li et al. point that, there is generally an optimal range for $m^{\prime}~{}(=n^{\prime})$, namely, when the value of $m^{\prime}$ is far away from the optimal range, the detection performance will become worse. This interesting phenomenon is explained as: When the size of the cropped images is too large, there is not much diversity in the randomly cropped images, and as such, each sub-clustering tends to generate same result. The benefit of clustering ensemble may disappear. When the size of the cropped images is too small, the statistical features of the images become unstable, leading to poor detection in each sub-clustering.

Experiments reported in [9] show that LI-250 outperforms pervious popular JPEG steganalysis features PEV-274 [7], LIU-144 [23], DCTR-8000 [24], and PHARM-12600 [25], which is explained as: on the one hand, comparing with PEV-274 and LIU-144, LI-250 could well reveal the changes of cover elements caused by the tested steganographic algorithms; on the other hand, although DCTR-8000 and PHARM-12600 are conclusively more sensitive for supervised binary classification, they have a high dimension and contain a number of weak features, which may lead to worse performance for SIP [6, 26].

Usually, for single hierarchical clustering, better performance can be obtained when the images are with large sizes [27]. However, good performance with large image size in the single hierarchical clustering method does not imply good performance of clustering ensemble using the same large image size for Li et al.’s method. That is, when the size of cropped images is too large, the diversity in the randomly cropped images is reduced, and thus multiple clustering rounds are likely to generate the same result. The benefit of clustering ensemble disappears. Therefore, it can be said that, the preprocessing operation may have significant impact on the detection performance.

Intuitively, the higher $T$, the higher the overall accuracy, but the longer the running time. In [9], the overall accuracy is tending towards stability with an increasing $T$, and does not change seriously when $T$ is larger than a threshold. It is believed that, the cropped images have a lot of overlapped area when $T$ increases, while the diversity will be reduced implying that multiple sub-models may generate the same results.

It can be easily inferred that the clustering ensemble framework shown in Figure 1.6 can be applied to other detection methods (e.g., LOF-based), by making adjustments accordingly. We do not provide more discussion here.

2 Dimensionality Reduction

Different from clustering ensemble (which has good generalization in terms of technical framework), dimensionality reduction focuses on the process of reducing the number of random variables under consideration by obtaining a set of principal variables. There are two important approaches for dimensionality reduction: feature selection and feature projection.

Feature Selection

Feature selection attempts to select a feature subspace from the original full feature space. Feature selection is often used in domains where there are many features and comparatively few sample points. Feature selection simplifies the model, and thus results in a shorter running time. It can also avoid disasters due to the dimensional problem. For SIP, in mainstream works, the distances in high dimensional space between features of actors are determined to find the abnormal cluster or outlier corresponding to the steganographer. However, in the high dimensional space, the distances between feature points may become similar to each other, resulting in that, it is not easy to separate the abnormal points from the normal ones. To this end, Wu [28] uses a simple feature selection based ensemble algorithm for SIP. The method merges results from multiple detection sub-models, each of which feature space is randomly sampled from the raw full dimensional space. Unlike the basic framework, the images held by a single actor are divided into multiple disjoint sets, resulting in that, each actor is represented by multiple sets of feature vectors.

In detail, let $A=\{a_{1},a_{2},...,a_{n}\}$ and $S(a_{i})=\{\textbf{I}_{1}^{(i)},\textbf{I}_{2}^{(i)},...,\textbf{I}_{m}^{(i)}\}$ respectively represent actors and the images held by actor $a_{i}$. A detector computes the preprocessed features for each $a_{i}$, i.e., $F(a_{i})=\{\textbf{f}_{1}^{(i)},\textbf{f}_{2}^{(i)},...,\textbf{f}_{m}^{(i)}\}$. All $F(a_{i})~{}(1\leq i\leq n)$ are divided to disjoint sets with an identical size, i.e.,

[TABLE]

where $m=p\cdot q$ and $P_{j}(a_{i})=\{\textbf{f}_{jq-q+1}^{(i)},\textbf{f}_{jq-q+2}^{(i)},...,\textbf{f}_{jq}^{(i)}\}$.

Accordingly, each $a_{i}$ can be represented by $p$ set of feature vectors. We call the $p$ sets as “$p$ points”. We can collect a total of $p\cdot n$ points, each of which belongs to one of the $n$ actors. It is naturally assumed that, distances between an abnormal point and a normal point should be larger than that between two normal points. In other words, normal points are densely distributed while abnormal ones are sparsely distributed. For any two points, we can use MMD or other metrics to measure their distance. However, when a point has only one feature vector, we cannot use MMD since its value always equals zero. In this case, one may adopt the Euclidean distance or other suitable metrics. Therefore, by anomaly detection (e.g., LOF detection), a ranking list for the $pn$ points is determined according to their anomaly scores.

We use $pn$ triples $\{(u_{i},v_{i},w_{i})\}_{i=1}^{pn}$ to denote the sorted information, where $u_{1}\geq u_{2}\geq...\geq u_{pn}$ represent the anomaly scores. $v_{i}$ denotes the corresponding actor and $w_{i}$ is the point index, namely, we have $P_{w_{i}}(v_{i})\in P(v_{i})$. For each actor $a_{i}$, we can determine a fusion score below:

[TABLE]

where $\delta(x,y)=1$ if $x=y$, otherwise $\delta(x,y)=0$. By sorting the fusion scores, we can generate the final ranking list, where the actor with the largest score will be the most suspicious.

In this way, we can construct a single anomaly detection system operated on the full feature space. Obviously, we can build $T$ sub-models $\{\mathcal{M}_{1},\mathcal{M}_{2},$ …, $\mathcal{M}_{T}\}$, whose feature dimensions are $\{d_{1},d_{2},...,d_{T}\}$. Each $d_{i}~{}(1\leq i\leq T),$ is chosen from $[H/2,H-1]$, where $H$ is the dimension of the raw full feature space. It is seen that, each sub-model is exactly the same as the single anomaly detection system, except that the used features are randomly sampled from the full feature space. For each $\mathcal{M}_{i}$, we can collect a ranking list, denoted by $\textbf{r}_{i}$ = $\{r_{i,1}$, …, $r_{i,n}\}$, and $r_{i,j}$ means the actor with the $j$-th largest anomaly score, i.e., $r_{i,1}$ is the most suspicious and $r_{i,n}$ is the least suspicious. Accordingly, by further processing $\{\textbf{r}_{1},\textbf{r}_{2},...,\textbf{r}_{T}\}$, the final fusion score for $a_{i}$ can be:

[TABLE]

By sorting $\{s_{\text{F}}(a_{1}),...,s_{\text{F}}(a_{n})\}$, the actor with the largest score will be the most suspicious, and the smallest score corresponds to the least suspicious.

It is observed that the method has the ability to improve the performance, which, however, is not significant and could be affected by parameter settings. For performance optimization, one may design advanced feature selection algorithms for choosing efficient feature components for detection.

Feature Projection

Feature projection should be distinguished from feature selection. While feature selection returns a subset of the original features by somehow way, feature projection creates new features from functions of the original features. It is excepted that, the projections of the original high dimensional features exhibit maximal information about the class label. Same as the feature selection, feature projection also reduces the complexity to help avoid over-fitting. For feature projection, the feature transformation can be either linear or non-linear. E.g., the linear principle components analysis (PCA) [29] performs a linear mapping of the raw features to a lower-dimensional space such that the variance of the features in the lower-dimensional representation is maximized. Kernel PCA [30], as a non-linear extension of PCA, uses a kernel to enable the originally linear operations of PCA to be performed in a RKHS.

Pevn$\acute{\text{y}}$ and Ker [26] have provided profound study on feature projection for SIP. They limit themselves to linear feature projections because it is believed that the steganalysis problem is essentially linear “in some sense”, e.g., experiments in [31] demonstrate that accurate estimators of payload size can be created as linear functions of feature vectors. As pointed by [26], we cannot expect that all stego objects move in the same direction, certainly not when created with direrent stego algorithms, nor that cover objects begin from nearby points if they arise from different sources. The boundary between cover and stego objects may be nonlinear. Accordingly, a good set of condensed features will be a collection of different linear projections, which between them capture the behaviour of different cover objects, sources, and embedding algorithms.

Therefore, to achieve better performance, they exploit principal component transformation (PCT), maximum covariance transformation, ordinary least square regression, and calibrated least squares regression for feature projection. The PCT can be defined as an iterative algorithm, where in $k$-th iteration one seeks a projection vector $w_{k}\in\mathbb{R}^{d}$ best explaining the raw features and being orthogonal to all projections $\{w_{i}\}_{i=1}^{k-1}$. It is formulated as:

[TABLE]

subject to $w^{\text{T}}w_{i}=0,\forall i\in[1,k-1]$. $w_{k}$ is $k$-th eigenvector of $\textbf{X}^{\text{T}}\textbf{X}$, assuming that the vectors are sorted such that the eigenvalue sequence is non-increasing.

A weakness of PCT is that, it does not take into account the objective function. Pevn$\acute{\text{y}}$ and Ker define the object function as the presence of steganography signalled by the steganographic change rate. It is to some extent resolved by finding a direction maximizing the covariance between the projected data $\textbf{X}^{s}w$ and the dependent variable $\textbf{Y}^{s}$. Also, $w_{k}$ should be orthogonal to $\{w_{i}\}_{i=1}^{k-1}$. It is called the Maximum CoVariance (MCV) transformation method, which can be formulated as:

[TABLE]

subject to $w^{\text{T}}w_{i}=0,\forall i\in[1,k-1]$. The analytical solution is $w_{k}={\textbf{Y}^{s}}^{\text{T}}\textbf{X}_{k}^{s}$, where $\textbf{X}_{k}^{s}=\textbf{X}_{k-1}^{s}(\textbf{I}-w_{k-1}w_{k-1}^{\text{T}})$, and $\textbf{X}_{1}^{s}=\textbf{X}^{s}$.

Ordinary Least Square regression (OLS) finds a single direction $w$ minimizing the total square error between $\textbf{X}^{s}w$ and $\textbf{Y}^{s}$. Such optimization problem can be formulated as:

[TABLE]

the analytical solution of which is:

[TABLE]

which assumes that, ${\textbf{X}^{s}}^{\text{T}}\textbf{X}^{s}$ is regular and the inversion is numerically stable. In practice, this is not always true, and steganalysis features may lead to a nearly singular matrix. To alleviate this, a small diagonal matrix is added to prevent non-singularity and increase the stability of the solution:

[TABLE]

Good steganographic projections should be sensitive to embedding changes yet insensitive to the object content, meaning that, the covariance between the projection of stego features and their embedding change rate should be high, while the variance of projection of cover features should be low. This objective is not optimized in any of the above methods. To this end, Pevn$\acute{\text{y}}$ and Ker propose a so-called calibrated least squares (CLS) regression method, which finds the projections by iteratively solving:

[TABLE]

subject to $w^{\text{T}}w_{i}=0,\forall i\in[1,k-1]$. And, the analytical solution is:

[TABLE]

where $\textbf{X}_{k}^{s}=\textbf{X}_{k-1}^{s}(\textbf{I}-w_{k-1}w_{k-1}^{\text{T}})$, $\textbf{X}_{1}^{s}=\textbf{X}^{s}$, and $\textbf{X}_{k}^{c}=\textbf{X}_{k-1}^{c}(\textbf{I}-w_{k-1}w_{k-1}^{\text{T}})$, $\textbf{X}_{1}^{c}=\textbf{X}^{c}$.

Instead of PEV-274, Pevn$\acute{\text{y}}$ and Ker use CF-7850 [32] and outlier detection [6] for experiments. Experimental results show that, in terms of identification accuracy (i.e., the average rank of the only one guilty actor), the unsupervised PCT method is worst. The MCV method is inferior to OLS in most situations, and CLS is significantly superior to the others. The explanation can be described as follows: PCT focuses on the explanation of the variance in the data, which is not exactly on par with our goal, as the variance in features can be dominated by cover image content. MCV finds directions maximally correlated with the explained variable (change rate). Although this is better than PCT, the image content acting as noise is not suppressed. OLS maximizes the covariance of a projection with the payload and minimizes the variance of the projection. Since the covariance and variance of projections are measured on the same data, it is not clear whether the variance comes from image content or from embedding changes, whereas, CLS removes this ambiguity.

5 Conclusion and Further Research

In this chapter, we have reviewed the problem of steganographer identification, in which we aim to identify a steganographer who sends many images (some of them may be innocent) in social networks or public environment of many other innocent users. The analyzer must deal with multiple users and multiple images per user, and particularly the differences between cover sources, as well as the differences between the covers and the stegos.

In despite of being posed for more than ten years, this problem was first addressed by Ker and Pevn$\acute{\text{y}}$ [5] in 2011. They introduced two general technical frameworks for steganographer identification, i.e., clustering-based detection and outlier-based detection. It can be said that, most of the advanced works reported in the literature are based on them. Though, throughout this chapter, we consider only one guilty actor (i.e., the steganographer), we can actually identify a short list of $k$ most suspicious actors.

It has been shown that, both ensemble and dimensionality reduction can improve the identification performance. As a common operation used in steganalysis, ensemble merges results from multiple sub-models to make a final decision. Dimensionality reduction, seeming to be more important, exploits salient features and eliminates irrelevant feature fluctuations by representing the discriminative information in a lower dimensional manifold [33].

The outlier-based analyzer is not compatible with rich features containing lots of weak features, because the weak features contain lots of noise (caused by cover content), resulting in inferior performance. Pevn$\acute{\text{y}}$ and Ker [26] used supervised feature reduction methods to improve performance, meaning that, the complete outlier detector was no longer unsupervised. However, the features showed a high level of robustness to varying the embedding algorithm, meaning that the outlier detector retained its universal behaviour. Finding the balance between supervision (to focus information) and universality (for robustness) is an important challenge for pooled steganalysis for SIP, which needs further investment.

Building upon advances in machine learning, Pevn$\acute{\text{y}}$ and Nikolaev [34] attempted to learn an optimal pooling function for pooled steganalysis. Although experiments show that learned combining functions are superior to the prior art, many interesting phenomenons were found, pointing to directions of further research, e.g., are there better strategies for the steganographer to distribute the message into multiple objects, or the linear strategy is the best he can do despite the steganalyzer knowing it? It is believed that, more questions will arise as the study of SIP moves ahead [35].