对此的正确术语是“隐写术”。
以下文章阐述了隐写术的定义：
隐写术是通过将信息嵌入其他信息来隐藏信息的艺术和科学。隐写术的工作原理是用一些不同的、不可见的信息替换常规计算机文件中无用或未使用的数据。这些隐藏信息可以是纯文本、密文，甚至是图片
逐步解释隐写术的工作原理：
- 遍历图像的像素。在每次迭代中，将 RGB 值分别分隔为一个单独的整数。
- 对于 R、G 和 B 中的每一个，使 LSB 等于 0。这些位将用于隐藏字符。
- 获取当前字符并将其转换为整数。然后将其8位隐藏在R1，G1，B1，R2，G2，B2，R3，G3中，其中数字是指像素的数量。在这些元素的每个 LSB（从 R1 到 G3）中，连续隐藏字符的位。
- 字符的8位处理完后，跳转到下一个字符，重复这个过程，直到处理完整个文本。
- 文字可以根据文字的长度隐藏在图像的一小部分。因此，必须有一些东西表明我们到了文本的结尾。该指标只是 8 个连续的零。从图像中提取文本时需要这样做。
这比隐藏更简单。只需通过像素
直到找到 8 个连续的零。当你经过时，选择
来自每个像素元素（R、G、B）的 LSB 并将其附加到一个空的
价值。当这个值的 8 位完成后，将其转换回
字符，然后将该字符添加到您要查找的结果文本中。
示例源代码如下：：
class SteganographyHelper
{
public enum State
{
Hiding,
Filling_With_Zeros
};
public static Bitmap embedText(string text, Bitmap bmp)
{
// initially, we'll be hiding characters in the image
State state = State.Hiding;
// holds the index of the character that is being hidden
int charIndex = 0;
// holds the value of the character converted to integer
int charValue = 0;
// holds the index of the color element (R or G or B) that is currently being processed
long pixelElementIndex = 0;
// holds the number of trailing zeros that have been added when finishing the process
int zeros = 0;
// hold pixel elements
int R = 0, G = 0, B = 0;
// pass through the rows
for (int i = 0; i < bmp.Height; i++)
{
// pass through each row
for (int j = 0; j < bmp.Width; j++)
{
// holds the pixel that is currently being processed
Color pixel = bmp.GetPixel(j, i);
// now, clear the least significant bit (LSB) from each pixel element
R = pixel.R - pixel.R % 2;
G = pixel.G - pixel.G % 2;
B = pixel.B - pixel.B % 2;
// for each pixel, pass through its elements (RGB)
for (int n = 0; n < 3; n++)
{
// check if new 8 bits has been processed
if (pixelElementIndex % 8 == 0)
{
// check if the whole process has finished
// we can say that it's finished when 8 zeros are added
if (state == State.Filling_With_Zeros && zeros == 8)
{
// apply the last pixel on the image
// even if only a part of its elements have been affected
if ((pixelElementIndex - 1) % 3 < 2)
{
bmp.SetPixel(j, i, Color.FromArgb(R, G, B));
}
// return the bitmap with the text hidden in
return bmp;
}
// check if all characters has been hidden
if (charIndex >= text.Length)
{
// start adding zeros to mark the end of the text
state = State.Filling_With_Zeros;
}
else
{
// move to the next character and process again
charValue = text[charIndex++];
}
}
// check which pixel element has the turn to hide a bit in its LSB
switch (pixelElementIndex % 3)
{
case 0:
{
if (state == State.Hiding)
{
// the rightmost bit in the character will be (charValue % 2)
// to put this value instead of the LSB of the pixel element
// just add it to it
// recall that the LSB of the pixel element had been cleared
// before this operation
R += charValue % 2;
// removes the added rightmost bit of the character
// such that next time we can reach the next one
charValue /= 2;
}
} break;
case 1:
{
if (state == State.Hiding)
{
G += charValue % 2;
charValue /= 2;
}
} break;
case 2:
{
if (state == State.Hiding)
{
B += charValue % 2;
charValue /= 2;
}
bmp.SetPixel(j, i, Color.FromArgb(R, G, B));
} break;
}
pixelElementIndex++;
if (state == State.Filling_With_Zeros)
{
// increment the value of zeros until it is 8
zeros++;
}
}
}
}
return bmp;
}
public static string extractText(Bitmap bmp)
{
int colorUnitIndex = 0;
int charValue = 0;
// holds the text that will be extracted from the image
string extractedText = String.Empty;
// pass through the rows
for (int i = 0; i < bmp.Height; i++)
{
// pass through each row
for (int j = 0; j < bmp.Width; j++)
{
Color pixel = bmp.GetPixel(j, i);
// for each pixel, pass through its elements (RGB)
for (int n = 0; n < 3; n++)
{
switch (colorUnitIndex % 3)
{
case 0:
{
// get the LSB from the pixel element (will be pixel.R % 2)
// then add one bit to the right of the current character
// this can be done by (charValue = charValue * 2)
// replace the added bit (which value is by default 0) with
// the LSB of the pixel element, simply by addition
charValue = charValue * 2 + pixel.R % 2;
} break;
case 1:
{
charValue = charValue * 2 + pixel.G % 2;
} break;
case 2:
{
charValue = charValue * 2 + pixel.B % 2;
} break;
}
colorUnitIndex++;
// if 8 bits has been added,
// then add the current character to the result text
if (colorUnitIndex % 8 == 0)
{
// reverse? of course, since each time the process occurs
// on the right (for simplicity)
charValue = reverseBits(charValue);
// can only be 0 if it is the stop character (the 8 zeros)
if (charValue == 0)
{
return extractedText;
}
// convert the character value from int to char
char c = (char)charValue;
// add the current character to the result text
extractedText += c.ToString();
}
}
}
}
return extractedText;
}
public static int reverseBits(int n)
{
int result = 0;
for (int i = 0; i < 8; i++)
{
result = result * 2 + n % 2;
n /= 2;
}
return result;
}
}
来源文章：http://www.codeproject.com/Tips/635715/Steganography-Simple-Implementation-in-Csharp