Hacklog » c/c++

BlowFish 加密算法Bcrypt

荒野无灯 — Fri, 14 Oct 2011 14:56:57 +0000

Blowfish是1993年布鲁斯·施奈尔(Bruce Schneier)开发的对称密钥区块加密算法，区块长为64位，密钥为1至448位的可变长度。与DES等算法相比，其处理速度较快。因为其无须授权即可使用，作为一种自由授权的加密方式在SSH、文件加密软件等被广泛地使用。

关于此算法的发明者：

布鲁斯·施奈尔（Bruce Schneier，1963年1月15日－）是一位美国的密码学学者、信息安全专家与作家。他撰写了数本信息安全与密码学相关的书籍，并且创办了BT公司并担任其首席技术官(CTO)。

分组密码(Block cypher)

分组密码（Block cypher，又称分块密码），是一种对称密钥密码。它的特点是将明文分成多个等长的组，并用相同的密码算法和密钥对每组分别进行加密和解密。其中典型的如DES和AES作为美国政府核定的标准加密算法，应用领域从电子邮件加密到银行交易转帐，非常广泛。
blowfish属于分组密码中的一种。

要了解blowfish加密算法，也许我们应该先了解一下Feistel 密码,因为blowfish加密算法也是feistel密码算法中的一种：
假设F是轮函数，然后K₀到K_n作为0到n轮的sub-keys,
基本的操作如下：

把明文分为相等的两块：L₀和R₀,
对于每一轮i=0,1,2,…,n 进行如下运算：
L_i+1 = R_i
R_i+1 = L_i ^ F(R_i,K_i)
最后得到密文(R_n+1,L_n+1)
解密(R_n+1,L_n+1)是通过如下步骤来完成的：
令i=n,n-1,…,0
R_i = L_i+1
L_i = R_i+1 ^ F(L_i+1,K_i)
最后又得到原来的(L₀,R₀)了

这么说可能不好理解，看下图（来自wikipedia)就清楚了：

简单地说：
就是一种分组密码，一般分为64位一组，一组分左右部分，进行一般为16轮的迭代运算，每次迭代完后交换左右位置，可以自己进行设计的有:
分组大小
密钥长度
轮次数
子密钥生成
轮函数

然后应该了解一下块密码的工作模式：
from wikipedia:

密码学中，块密码的工作模式允许使用同一个块密码密钥对多于一块的数据进行加密，并保证其安全性。[1][2] 块密码自身只能加密长度等于密码块长度的单块数据，若要加密变长数据，则数据必须先被划分为一些单独的密码块。通常而言，最后一块数据也需要使用合适填充方式将数据扩展到符合密码块大小的长度。一种工作模式描述了加密每一数据块的过程，并常常使用基于一个通常称为初始化向量的附加输入值以进行随机化，以保证安全[1]。

工作模式主要用来进行加密和认证。[1][3] 对加密模式的研究曾经包含数据的完整性保护，即在某些数据被修改后的情况下密码的误差传播特性。后来的研究则将完整性保护作为另一个完全不同的，与加密无关的密码学目标。部分现代的工作模式用有效的方法将加密和认证结合起来，称为认证加密模式。[2]

虽然工作模式通常应用于对称加密[2]，它亦可以应用于公钥加密，例如在原理上对RSA进行处理，但在实用中，公钥密码学通常不用于加密较长的信息，而是使用混合加密方案

一般来说常用的加密模式有这么几种：

电子密码本（ECB）
密码块链接（CBC）：在CBC模式中，每个平文块先与前一个密文块进行异或后，再进行加密。在这种方法中，每个密文块都依赖于它前面的所有平文块。同时，为了保证每条消息的唯一性，在第一个块中需要使用初始化向量。
填充密码块链接（PCBC）
密文反馈（CFB）
输出反馈（OFB）
计数器模式（CTR）

初始化向量（IV）

初始化向量（IV，Initialization Vector）是许多工作模式中用于随机化加密的一块数据，因此可以由相同的明文，相同的密钥产生不同的密文，而无需重新产生密钥，避免了通常相当复杂的这一过程。

初始化向量与密钥相比有不同的安全性需求，因此IV通常无须保密，然而在大多数情况中，不应当在使用同一密钥的情况下两次使用同一个IV。对于CBC和CFB，重用IV会导致泄露平文首个块的某些信息，亦包括两个不同消息中相同的前缀。对于OFB和CTR而言，重用IV会导致完全失去安全性。另外，在CBC模式中，IV在加密时必须是无法预测的；特别的，在许多实现中使用的产生IV的方法，例如SSL2.0使用的，即采用上一个消息的最后一块密文作为下一个消息的IV，是不安全的[12]。

填充

块密码只能对确定长度的数据块进行处理，而消息的长度通常是可变的。因此部分模式（即ECB和CBC）需要最后一块在加密前进行填充。有数种填充方法，其中最简单的一种是在平文的最后填充空字符以使其长度为块长度的整数倍，但必须保证可以恢复平文的原始长度；例如，若平文是C语言风格的字符串，则只有串尾会有空字符。稍微复杂一点的方法则是原始的DES使用的方法，即在数据后添加一个1位，再添加足够的0位直到满足块长度的要求；若消息长度刚好符合块长度，则添加一个填充块。最复杂的则是针对CBC的方法，例如密文窃取，残块终结等，不会产生额外的密文，但会增加一些复杂度。布鲁斯·施奈尔和尼尔斯·弗格森提出了两种简单的可能性：添加一个值为128的字节（十六进制的80），再以0字节填满最后一个块；或向最后一个块填充n个值均为n的字节[13]。

CFB，OFB和CTR模式不需要对长度不为密码块大小整数倍的消息进行特别的处理。因为这些模式是通过对块密码的输出与平文进行异或工作的。最后一个平文块（可能是不完整的）与密钥流块的前几个字节异或后，产生了与该平文块大小相同的密文块。流密码的这个特性使得它们可以应用在需要密文和平文数据长度严格相等的场合，也可以应用在以流形式传输数据而不便于进行填充的场合。

另外在mcrypt的man文档里也找到了加密模式的介绍：

加密模式

modes of encryption:
ECB: The Electronic CodeBook mode. It is the simplest mode to use with a block cipher. Encrypts each block independently.

CBC: The Cipher Block Chaining mode. It is better than ECB since the plaintext is XOR’ed with the previous ciphertext. A random block is placed as the first block so the same block or messages always encrypt to something different. (This is the default mode)

CFB: The Cipher-Feedback Mode (in 8bit). This is a self-synchronizing stream cipher implemented from a block cipher.

OFB: The Output-Feedback Mode (in 8bit). This is a synchronous stream cipher implemented from a block cipher. It is intended for use in noisy lines, because corrupted ciphertext blocks do not corrupt the plaintext blocks that follow. Insecure (because used in 8bit mode) so I recommend against using it. Added just for completeness.

nOFB: The Output-Feedback Mode (in nbit). n Is the size of the block of the algorithm. This is a synchronous stream cipher implemented from a block cipher. It is intended for use in noisy lines, because corrupted ciphertext blocks do not corrupt the plaintext blocks that follow.

via http://mcrypt.hellug.gr/mcrypt/mcrypt.1.html
BTW,The author of mcrypt and libmcrypt is Nikos Mavroyanopoulos.

分块大小

Block size

现代加密算法中，对称密钥算法通常被分为stream ciphers和block ciphers。分块密码处理固定长度的字符串位数(bit)。这个比特字符串的长度必须和分块大小一样长。输入（明文）和输出（密文）都是同样长度的。输出不能比输入短——这是遵循Pigeonhole principle（鸽巢原理，又名狄利克雷抽屉原理、鸽笼原理）和密码必须是可逆的事实——然而，输出比输入更长又是不可取的。

鸽巢原理：

其中一种简单的表述法为：
若有n个笼子和n+1只鸽子，所有的鸽子都被关在鸽笼里，那么至少有一个笼子有至少2只鸽子。
另一种为：
若有n个笼子和kn+1只鸽子，所有的鸽子都被关在鸽笼里，那么至少有一个笼子有至少k+1只鸽子。
拉姆齐定理是此原理的推广。

通俗点说：
10只鸽子放进9个鸽笼，那么一定有一个鸽笼放进了至少两只鸽子。

S-box (Substitution-box,替换盒)
在分块密码中，S-box通常被用来掩盖密钥和密文之间的关系。

In general, an S-Box takes some number of input bits, m, and transforms them into some number of output bits, n: an m×n S-Box can be implemented as a lookup table with 2m words of n bits each. Fixed tables are normally used, as in the Data Encryption Standard (DES), but in some ciphers the tables are generated dynamically from the key; e.g. the Blowfish and the Twofish encryption algorithms. Bruce Schneier describes IDEA’s modular multiplication step as a key-dependent S-Box.

IDEA(International Data Encryption Algorithm)

Rijndael S-box

算法说明：
BlowFish 使用了两个box,除了著名的S-box，还有一个p-box
pbox有18个unsigned long元素
sbox有4×256个unsigned long元素
BlowFish算法中，有一个核心加密函数，该函数输入64位信息，运算后，以64位密文的形式输出。用BlowFish算法加密信息，需要两个过程：
这里我看的源码是Paul Kocher的C语言版本。
源码下载地址：http://www.schneier.com/blowfish-download.html

1.密钥预处理
2.信息加密

结构体定义：

1
2
3
4

typedef struct {
unsigned long P[16 + 2];
unsigned long S[4][256];
} BLOWFISH_CTX;

1.密钥预处理
BlowFish算法的源密钥——pbox和sbox是固定的。此pbox和sbox的值来自PI的十六进制数字值，使用这些数的原因是这些数看不出有什么明显的规律。(PI)
这里摘取1-500位：

3.243F6A8885 A308D31319 8A2E037073 44A4093822 299F31D008
  2EFA98EC4E 6C89452821 E638D01377 BE5466CF34 E90C6CC0AC
  29B7C97C50 DD3F84D5B5 B547091792 16D5D98979 FB1BD1310B
  A698DFB5AC 2FFD72DBD0 1ADFB7B8E1 AFED6A267E 96BA7C9045
  F12C7F9924 A19947B391 6CF70801F2 E2858EFC16 636920D871
  574E69A458 FEA3F4933D 7E0D95748F 728EB65871 8BCD588215
  4AEE7B54A4 1DC25A59B5 9C30D5392A F26013C5D1 B023286085
  F0CA417918 B8DB38EF8E 79DCB0603A 180E6C9E0E 8BB01E8A3E
  D71577C1BD 314B2778AF 2FDA55605C 60E65525F3 AA55AB9457
  48986263E8 144055CA39 6A2AAB10B6 B4CC5C3411 41E8CEA154

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

void Blowfish_Init(BLOWFISH_CTX *ctx, unsigned char *key, int keyLen) {
int i, j, k;
unsigned long data, datal, datar;

for (i = 0; i < 4; i++) {
for (j = 0; j < 256; j++)
ctx->S[i][j] = ORIG_S[i][j];
}

j = 0;
for (i = 0; i < N + 2; ++i) {
data = 0x00000000;
for (k = 0; k < 4; ++k) {
data = (data << 8) | key[j];
j = j + 1;
if (j >= keyLen)
j = 0;
}
ctx->P[i] = ORIG_P[i] ^ data;
}

datal = 0x00000000;
datar = 0x00000000;

for (i = 0; i < N + 2; i += 2) {
Blowfish_Encrypt(ctx, &datal, &datar);
ctx->P[i] = datal;
ctx->P[i + 1] = datar;
}

for (i = 0; i < 4; ++i) {
for (j = 0; j < 256; j += 2) {
Blowfish_Encrypt(ctx, &datal, &datar);
ctx->S[i][j] = datal;
ctx->S[i][j + 1] = datar;
}
}
}

我们要加密一个信息，
需要自己选择一个key，用这个key对pbox和sbox进行变换，得到下一步信息加密
所要用的pbox和sbox。
具体的变化算法如下：
用原sbox: ORIG_S 填充 sbox

然后，每次取key与data进行运算，运算后的结果送给pbox
运算过程是这样的：
进行N+2次运算（N=16),
令 32位无符号data为0,由于Key是unsigned char类型的，每次对data左移8位(一个字节)之后与
相应的key相或（即相加），当key长度小于4时，循环使用Key。

接下来，用bf_encypt加密一个全0的64位信息（分为datal和datar,各32位）
用输出的结果datal和datar分别替换pbox[0]和pbox[1]
然后，继续加密datal和datar,用输出结果替换pbox[2]和pbox[3]
……
这样循环18次，把pbox全部替换完成。

接下来是对sbox的替换了。
这次总共是循环4×256次，每次循环的过程与上面的一样。
不过这里用的datal和datar就是上面运算过后的datal和datar.

2.信息加密
接下来看这个加密函数，上面的初始化过程已经用到它了。

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

void Blowfish_Encrypt(BLOWFISH_CTX *ctx, unsigned long *xl, unsigned long *xr){
unsigned long Xl;
unsigned long Xr;
unsigned long temp;
short i;

Xl = *xl;
Xr = *xr;

for (i = 0; i < N; ++i) {
Xl = Xl ^ ctx->P[i];
Xr = F(ctx, Xl) ^ Xr;

temp = Xl;
Xl = Xr;
Xr = temp;
}

temp = Xl;
Xl = Xr;
Xr = temp;

Xr = Xr ^ ctx->P[N];
Xl = Xl ^ ctx->P[N + 1];

*xl = Xl;
*xr = Xr;
}

与上面说的Feistel 密码的运算过程是一样的：
把64位的明文分为l和r
进行16轮运算：
令i=0,1,2,3,…,N-1
Xl = Xl ^ ctx->P[i];
Xr = F(ctx, Xl) ^ Xr;
若i 16轮运算完了之后，再做一次Xl与Xr的交换，因为第16次运算完了之后，实际上
没有再做运算了，但是Xl与Xr还是交换了，因此，得换回来。

然后，Xr = Xr ^ ctx->P[N];
Xl = Xl ^ ctx->P[N + 1];
现在的Xl和Xr就是加密后的数据了。
加密过程图解：

这加密过程中用到了F变换：

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

static unsigned long F(BLOWFISH_CTX *ctx, unsigned long x) {
unsigned short a, b, c, d;
unsigned long y;

d = (unsigned short)(x & 0xFF);
x >>= 8;
c = (unsigned short)(x & 0xFF);
x >>= 8;
b = (unsigned short)(x & 0xFF);
x >>= 8;
a = (unsigned short)(x & 0xFF);
y = ctx->S[0][a] + ctx->S[1][b];
y = y ^ ctx->S[2][c];
y = y + ctx->S[3][d];

return y;
}

这个变换是这样的：
它接收一个32位的数据，然后从高位到低位分为四段，每段8位，依次给
a,b,c,d
取sbox[0][a]+sbox[1][b]，相加后的结果再与sbox[2][c]做异或运算，
得出的结果再加上sbox[3][d]
由于sbox的元素都是32位的，因此，F变换后的输出也是32位的。
轮函数图解：

解密函数：
可以看到解密函数与加密函数非常的相似，只是把p0,p1,…,p17 逆序使用：

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

void Blowfish_Decrypt(BLOWFISH_CTX *ctx, unsigned long *xl, unsigned long *xr){
unsigned long Xl;
unsigned long Xr;
unsigned long temp;
short i;

Xl = *xl;
Xr = *xr;

for (i = N + 1; i > 1; --i) {
Xl = Xl ^ ctx->P[i];
Xr = F(ctx, Xl) ^ Xr;

/* Exchange Xl and Xr */
temp = Xl;
Xl = Xr;
Xr = temp;
}

/* Exchange Xl and Xr */
temp = Xl;
Xl = Xr;
Xr = temp;

Xr = Xr ^ ctx->P[1];
Xl = Xl ^ ctx->P[0];

*xl = Xl;
*xr = Xr;
}

关于BlowFish 密码，个人认为可以把它理解为一种复杂的异或密码,异或运算的规律：

A ^ 0 = A
A ^ A = 0
(A ^ B) ^ C = A ^ (B ^ C)
(B ^ A) ^ A = B ^ 0 = B

按这种逻辑，文本序列的每个字符可以通过与给定的密钥进行按位异或运算来加密。如果要解密，只需要将加密後的结果与密钥再次进行按位异或运算即可。

喜欢这篇文章吗?

请订阅本站 RSS feed 或

作者：荒野无灯
出处：Hacklog【荒野无灯weblog】

声明: 本站遵循署名-非商业性使用-相同方式共享 2.5 共享协议. 转载请注明转自Hacklog【荒野无灯weblog】

本文链接: http://ihacklog.com/?p=4939

随机日志

2012年01月3日 // Louis Han童鞋应该是中招了 (0)
2008年12月24日 // 一个人的天空很蓝，蓝得有点忧郁！ (0)
2011年07月6日 // PHP 真值表 (2)
2009年06月17日 // 批处理全自动配置IP地址,网关,dns (3)
2010年07月17日 // CurrPorts：windows下查看网络连接端口的利器 (0)
2010年12月12日 // Eclipse中SVN版本控制插件的安装和使用 (4)

关于C语言的char类型是有符号还是无符号

荒野无灯 — Fri, 24 Jun 2011 07:53:04 +0000

这是C语言里面比较纠结的一个问题。
有时候这个问题和平台或者编译器有关。
貌似gcc和 Ms cl 都默认是signed

1
2
3
4
5
6
7
8
9

#include
#include

int
main()
{
printf("%d\n",CHAR_MIN);
return 0;
}

输出是 -128 .

其实C标准并没有规定char 应该是unsigned 还是 signed
事实上标准定义了三种类型：char, signed char 和unsigned char
#include 然后检查CHAR_MIN 的值就知道默认的是有符号还是无符号。
若等于0 ，则说明是无符号的，否则，它就是等于SCHAR_MIN (一般是-128）。
我们查看下/usr/include/limits.h
可以发现如下定义：

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

/* Number of bits in a `char'. */
# define CHAR_BIT 8

/* Minimum and maximum values a `signed char' can hold. */
# define SCHAR_MIN (-128)
# define SCHAR_MAX 127

/* Maximum value an `unsigned char' can hold. (Minimum is 0.) */
# define UCHAR_MAX 255

/* Minimum and maximum values a `char' can hold. */
# ifdef __CHAR_UNSIGNED__
# define CHAR_MIN 0
# define CHAR_MAX UCHAR_MAX
# else
# define CHAR_MIN SCHAR_MIN
# define CHAR_MAX SCHAR_MAX
# endif

当然，这个默认行为也是可以通过编译器来改变的，如gcc可通过加-funsigned-char
来指定其默认为无符号型。
MSVC 可以用/J来指定char 默认为无符号型。

本文参考：
c – char is signed or unsigned by default – Stack Overflow

喜欢这篇文章吗?

请订阅本站 RSS feed 或

作者：荒野无灯
出处：Hacklog【荒野无灯weblog】

声明: 本站遵循署名-非商业性使用-相同方式共享 2.5 共享协议. 转载请注明转自Hacklog【荒野无灯weblog】

本文链接: http://ihacklog.com/?p=4579

Linux中gotoxy函数的一个实现

荒野无灯 — Thu, 02 Jun 2011 16:19:08 +0000

摘自：Linux: gotoxy() – C

Linux中要移动光标一般要用到ncurses库中的move函数，这里找到一个纯C实现的gotoxy函数：

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

#include
#include

void clrscr(void) {
int i;

for (i = 0; i < 100; i++)
// A bunch of new lines for now. It's blank, hey!
putchar('\n');
}

int gotoxy(int x, int y) {
char essq[100]; // String variable to hold the escape sequence
char xstr[100]; // Strings to hold the x and y coordinates
char ystr[100]; // Escape sequences must be built with characters

/*
** Convert the screen coordinates to strings
*/
sprintf(xstr, "%d", x);
sprintf(ystr, "%d", y);

/*
** Build the escape sequence (vertical move)
*/
essq[0] = '\0';
strcat(essq, "\033[");
strcat(essq, ystr);

/*
** Described in man terminfo as vpa=\E[%p1%dd
** Vertical position absolute
*/
strcat(essq, "d");

/*
** Horizontal move
** Horizontal position absolute
*/
strcat(essq, "\033[");
strcat(essq, xstr);
// Described in man terminfo as hpa=\E[%p1%dG
strcat(essq, "G");

/*
** Execute the escape sequence
** This will move the cursor to x, y
*/
printf("%s", essq);

return 0;
}

/*
** Example
*/
int main () {
clrscr();
gotoxy(2, 0);
printf("Coordinates: x = 2; y = 0;\n");
gotoxy(5, 5);
printf("Coordinates: x = 5; y = 5;\n");

return 0;
}

喜欢这篇文章吗?

请订阅本站 RSS feed 或

作者：荒野无灯
出处：Hacklog【荒野无灯weblog】

声明: 本站遵循署名-非商业性使用-相同方式共享 2.5 共享协议. 转载请注明转自Hacklog【荒野无灯weblog】

本文链接: http://ihacklog.com/?p=4552

文本文件批量合并小工具

荒野无灯 — Fri, 18 Mar 2011 08:52:55 +0000

在深圳时，奔爷有一小说要合并，win下用批处理貌似不好办，Linux下的shell 命令我也不是很熟悉，还是用C语言写一个吧，于是操刀(VIM)开工。因此有了这篇文章。程序很简单，没啥技术含量，拿出来与大家分享。有兴趣的童鞋可以一起来修改它。

Usage:./filecombine prefix start end [combine_name] [fileext]

Description:此程序用来合并命名有规律的txt文件为一个文件,
如foo1.txt , foo2.txt ,foo3.txt …… foo199.txt , foo200.txt
参数解释：
prefix: 文件共同的前缀(比如上面的 foo)
start: 要合并的文件的开始数字(如1)
end: 要合并的文件的结束数字(如200)
combine_name: 合并后的文件名称(可选)
fileext: 文件后缀(默认为.txt,可选)

1	gcc -Wall -o filecombine -O3 filecombine.c

源码如下，可在WIN32或者Linux 32下编译运行。win下access函数是用头文件io.h，linux下没有这个文件，包含于unistd.h中。
附上源码包，里面包含WIN32和LINUX下的可执行文件：
注意：该页面嵌入了下载文件，请访问该页面下载该文件。

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

/*
* =====================================================================================
*
* Filename: filecombine.c
*
* Description: 此程序用来合并命名有规律的txt文件为一个文件，如foo1.txt , foo2.txt ,foo3.txt ...... foo199.txt , foo200.txt
* 用法：filecombine.exe 文件共同的前缀(比如上面的 foo) 要合并的文件的开始数字(如1) 要合并的文件的结束数字(如200) [合并后的文件名称]
* (可选) [文件后缀](默认为.txt,可选)
* Version: 1.0
* Created: 2011年03月01日 21时52分28秒
* Revision: none
* Compiler: gcc
*
* Author: 荒野无灯 (HuangYeWuDeng), admin#ihacklog.com
* Company: hhtc edu
*
* =====================================================================================
*/
#include
#include
#include
#include
#include
#include

#if defined(WIN32)
#include
#elif defined(__linux__)
#include
#endif

#define CHUNK_SIZE 512

off_t filesize(char *);

int
main(int argc,char *argv[])
{
printf(" ************文本文件批量合并小工具************\n");

if(argc<4)
{
printf("Error parameter!\n");
printf("Usage:%s prefix start end [combine_name] [fileext]\n\n",*argv);
printf("Description:此程序用来合并命名有规律的txt文件为一个文件,\n如foo1.txt , foo2.txt ,foo3.txt ...... foo199.txt , foo200.txt\n参数解释：\nprefix: 文件共同的前缀(比如上面的 foo) \nstart: 要合并的文件的开始数字(如1)\nend: 要合并的文件的结束数字(如200) \ncombine_name: 合并后的文件名称(可选) \nfileext: 文件后缀(默认为.txt,可选)\n\n");
printf("--------------------------------------------------a small tool by 荒野无灯\n");
printf("--------------------------------------------------http://www.ihacklog.com\n\n");
return -1;
}

FILE *fp;
FILE *fpw;
char fileext[10];
char combine_filename[200];
char renamed_combine_filename[300];
if(argc==6)
sprintf(fileext,"%s",argv[5]);
else
strcpy(fileext,".txt");

if(NULL !=argv[4])
sprintf(combine_filename,"%s_combined%s",argv[4],fileext);
else
sprintf(combine_filename,"%s_combined%s",argv[1],fileext);

if(!access(combine_filename,0x00))
{
char timebuf[100];
time_t t;
time (&t);
strftime(timebuf, sizeof(timebuf),"%Y-%m-%d-%H%M%S", localtime(&t));

sprintf(renamed_combine_filename,"%s_%s",timebuf,combine_filename);
printf("注意：文件%s已经存在，合并后的文件名为：%s\n",combine_filename,renamed_combine_filename);

}
else
{
strcpy(renamed_combine_filename,combine_filename);
}

fpw=fopen(renamed_combine_filename,"ab");
if(!fpw)
{
printf("create file %s failed!\n",renamed_combine_filename);
return -1;
}
int i;

int start_num=atoi(argv[2]);
int end_num=atoi(argv[3])+1;
for(i=start_num;i<end_num;i++)
{
char fname[200];
strcpy(fname,argv[1]);
char tmp[10];
sprintf(tmp,"%d",i);
strcat(fname,tmp);
strcat(fname,fileext);
fp=fopen(fname,"rb");
if(!fp)
{
printf("Error:\nopen file %s failed!perhaps file does not exists.\n",fname);
return -1;
}
else
{
printf("正在添加文件: %s ......\n",fname);
char data[CHUNK_SIZE+1];
int file_size=filesize(fname);
int toread;
while(file_size>0 )
{
toread=( file_size>CHUNK_SIZE )?CHUNK_SIZE:file_size;
fread(data,toread,1,fp);
fwrite(data,toread,1,fpw);
file_size-=toread;
}
}
fclose(fp);

}
fclose(fpw);
printf("文件合并成功！合并后的文件名为：%s\n",renamed_combine_filename);
return 0;

}

off_t
filesize(char *filename)
{
struct stat s;
if(0 != stat(filename,&s))
return -1;
return s.st_size;

}

喜欢这篇文章吗?

请订阅本站 RSS feed 或

作者：荒野无灯
出处：Hacklog【荒野无灯weblog】

声明: 本站遵循署名-非商业性使用-相同方式共享 2.5 共享协议. 转载请注明转自Hacklog【荒野无灯weblog】

本文链接: http://ihacklog.com/?p=4317

avast病毒库更新程序的改进

荒野无灯 — Fri, 26 Nov 2010 01:12:26 +0000

avast病毒库更新程序为avast-update ，这个东东实际上是调用了wget 来下载病毒库的，但是运行以后没有任何提示，病毒库到底有没有在下载呢？不清楚。于是写了个东东来以便可以直观的看到是否在下载以及下载速度的快慢（根据旋转速度）。
/opt/avast4workstation-1.3.0/bin/avast-update 是 avast-update 的路径。

这个小程序主要用到了LINUX内核的 inotify 来监控文件变化。

TODO：
增加超时检测（超时自动退出）
增加更新完成后自动退出（这一点应该简单）

/*
* =====================================================================================
*
* Filename: avast-watch.c
*
* Description: 监视avast病毒库更新
*
* Version: 1.0
* Created: 2010年10月13日 13时35分28秒
* Revision: none
* Compiler: gcc
*
* Author: 荒野无灯 (HuangYeWuDeng), admin@ihacklog.com
* Company: hhtc edu
*
* =====================================================================================
*/

#include
#include
#include
#include
#define MAX_BUF_SIZE 4096

/*
struct inotify_event {
int wd; // watch descriptor
uint32_t mask; // mask of events
uint32_t cookie; // unique cookie associating related events ( form rename(2) )
uint32_t len; // size of name field
char name[]; // optional null-terminated name
}
*/

int main()
{
// fd : file discriptor
// wp watch discriptor
int fd, wd;
int len, index;
char buffer[4096];
struct inotify_event *event;
char *path = "/home/hacklog/.avast";
char *prog="/opt/avast4workstation-1.3.0/bin/avast-update";

int progress = 0;
char indicator[]="-\\|/";

FILE *fp=popen(prog,"r");

fd = inotify_init();
if (fd < 0)
{
printf("Failed to initialize inotify.\n");
return 1;
}
wd = inotify_add_watch(fd, path, IN_CLOSE_WRITE | IN_CREATE | IN_MODIFY| IN_DELETE );
if (wd < 0)
{
printf("Can't add watch for %s", path);
return 1;
}
// 当没有事件发生时，fd 处于阻塞状态，read阻塞直到有一个事件发生.
time_t start_time;
time_t end_time;
while (len = read(fd, buffer, MAX_BUF_SIZE))
{
index = 0;
while (index < len)
{

event = (struct inotify_event *) (buffer + index);
// 如果不是我们添加的对.avast目录的监视，就继续（因为我们可能添加了多个监视的，每个监视都有一个 wd (watch discriptor )
if (event->wd != wd)
continue;

// if (event->mask & IN_OPEN)
// printf("file %s is opened.\n", event->name);

if (event->mask & IN_CREATE)
{
if( strcmp(event->name,"400.vps.new.md5") == 0 )
{
time(&start_time);
}
printf("file %s is created.\n", event->name);
}

if (event->mask & IN_MODIFY)
{
// printf("file %s is modified.\n", event->name);
printf(" %c",indicator[progress]);
fflush(stdout);
printf("\b\b");
progress=( progress + 1 ) % 4;
}

if (event->mask & IN_CLOSE_WRITE)
{
printf("file %s is closed for write.\n", event->name);
}

if (event->mask & IN_DELETE)
printf("file %s is deleted.\n", event->name);

// sizeof(struct inotify_event)+len 为每个inotify_event 的长度
index += sizeof(struct inotify_event) + event->len;
}
}

return 0;
}

IBM DW：

参考文档：
inotify — Linux 2.6 内核中的文件系统变化通知机制
 linux开发 — 文件监控 inotify
扩展阅读：
linux inotify+rsync+ssh数据时时同步

喜欢这篇文章吗?

请订阅本站 RSS feed 或

作者：荒野无灯
出处：Hacklog【荒野无灯weblog】

声明: 本站遵循署名-非商业性使用-相同方式共享 2.5 共享协议. 转载请注明转自Hacklog【荒野无灯weblog】

本文链接: http://ihacklog.com/?p=4250

随机日志

2010年04月24日 // 折腾WordPress內置嵌套评论专用Ajax comments (32)
2011年06月6日 // font manager for linux (0)
2009年04月17日 // 想要精通PHP吗？先学好Linux/Unix和C吧 (0)
2009年04月5日 // SQL中like中的%的妙用 (0)
2011年04月28日 // drupal分类显示在菜单中的方法 (2)
2011年11月25日 // wordpress多用户站点配置 (1)

关于递归与迭代

荒野无灯 — Wed, 24 Nov 2010 06:08:52 +0000

这篇文章是由一道省二计算机等级考试的题目引发的。
那天寝室一同学的同学考省二，发短信过来求救，要我给他算一个题目。
题目简单描述如下：

f（0）=f（1）=1
f（2）=0
f(n)=f(n-1)-2*f(n-2)+f(n-3)
求当n<= 50 时 (n>2) f(n)的最大值是多少。

由于时间非常紧，那同学快下考了，首先我便用了简单的递归实现f(n)函数。

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

#include
int f(int n);
int main()
{

int i;
int max=0;
for(i=3;i<51;i++)
{
//printf("now :%d\n",i);
if(f(i) > max )
{
max=f(i);
}

}

printf("max=%d\n",max );
return 0;

}

int f(int n)
{
switch(n)
{
case 0:
case 1:
return 1;
break;
case 2:
return 0;
break;
default:
return f(n-1)-2*f(n-2)+f(n-3);
}
}

一运行，发现老半天不出结果，调试一下发现，算到n等于30多的时候就变得非常慢了，CPU占用达50%以上。很明显，这个函数不能用递归来实现。因为递归实际上效率是非常低的，而且，就这个题目而言，运算量非常大。
于是赶紧修改了一下f(n) 函数，转而用迭代来实现。

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

int f(int n)
{
int a,b,c,d;
a=b=1;
c=0;

switch(n)
{
case 0:
case 1:
return 1;
break;
case 2:
return 0;
break;
default:
int t=0;
while(n>2)
{
// a b c d
d=c-2*b + a;
t=d-2*c+b;
a=b;
b=c;
c=d;
d=t;

n--;
}
return d;
}

}

这样再运行，结果马上出来了： 598325
速给那同学把答案发去了。

后来，又再网上找到另一种更简便的方法，用一个数组来存储每次运算的结果，这样，后面的运行就可以直接利用前面运算得出的结果，而不要重新计算。从效率来说，这个更高一些。

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

#include
int main()
{

int arr[51],i,num_max=1;
arr[0]=arr[1]=1;
arr[2]=0;
for(i=3;i<=50;i++)
{
arr[i]=arr[i-1]-2*arr[i-2]+arr[i-3];
if(num_max<arr[i])
num_max=arr[i];
}
printf("max=%d\n",num_max);
return 0;
}

看来我还是把问题想复杂了，有时候，最简单的方法就是最好的方法。简单就是美。

喜欢这篇文章吗?

请订阅本站 RSS feed 或

作者：荒野无灯
出处：Hacklog【荒野无灯weblog】

声明: 本站遵循署名-非商业性使用-相同方式共享 2.5 共享协议. 转载请注明转自Hacklog【荒野无灯weblog】

本文链接: http://ihacklog.com/?p=4240

随机日志

2008年02月21日 // 页面转向代码 (0)
2009年04月9日 // 一个好用的分页类【我在discuz6.1首页背景音乐插件中用到】 (1)
2010年02月28日 // 禁用并删除wordpress修订记录 (3)
2011年12月1日 // 以后分享东西我还是用skydrive吧 (14)
2011年08月20日 // 原创插件：hb-Highslide (2)
2011年10月4日 // WP中检测脚本是否已经注册的方法 (0)

常量指针和指针常量——令人蛋疼的两个词

荒野无灯 — Sat, 23 Oct 2010 15:49:28 +0000

在《C专家编程》（徐波译）第64页：

最后，把” char * const ” 解释为指向字符的常量指针。

不知道原书中是怎样的。我们看一下原书：

Finally, take the “char * const”, as a constant pointer to a character.

可见，在本书中，”常量指针“ 代表的是”constant pointer” ,即这个指针本身是一个常量。也就是说指针本身是只读的，是不可修改的。
因为C语言中的const 关键字实际上是代表被它声明的对象是只读的，不可修改的。
char str[]=”Hello C!\n”;
char * const pchar=str;
这里pchar 是不可修改的，也就是说pchar 这个指针，它是个常量。
徐波把它翻译为常量指针，也是可以理解的。 constant 在这里是个形容词，用来修饰 pointer的。

http://www.codeguru.com/cpp/cpp/cpp_mfc/general/article.php/c6967

那 a pointer to a constant character ，应该把它认为是一个指针常量吧。它首先是一个指针，指向一个常量（字符常量）。

这样看来，
char * const pchar; //常量指针
char const * pchar; //指针常量，或指向常量的指针
似乎是合理的。
GOOGLE了一下，发现很多文章中的说法与上面的正好相反。
也有部分相同的，如http://faq.csdn.net/read/217386.html 就把第一种形式的解释为“常量指针” 。此文中说：

“常量指针”即指针本身的值是常量，但“能靠解引用改变它指向的对象的值”

5）关于记忆技巧：
对于区分const int *pa和int *const pa这两者，
前者中，const直接修饰*（不考虑int，因为类型在这里是没影响的），说明*（解引用）这种行为具有常量性，即“不能靠解引用改变它指向的对象的值”，即指向常量的指针。
后者中，const直接修饰pa，说明pa本身的值具有常量性，即常量指针。

或者也可以这样来记忆：
const int a; // const常量
const int *a; //指向常量的指针
int *const a=&n; //常量指针
你在纸上按顺序写下以上三行，记住它们的注释长度：短——长——短，
分别对应着：const常量、指向常量的指针、常量指针这三种，应该就不会混淆了。

个人认为以上记忆法比《Effective ++》条款21中推荐的划线分左右法更好记。

另1：也有教材反过来把上述第二者称呼为“常量指针”，第三者称呼为：“指针常量”，相对来说更容易让人混淆，大家还是只记住上面的那种称呼法就好。

另2：const和typedef在一起时容易让人陷入陷阱，具体见《typedef的用途和陷阱》。

相反的记法，可参见：

http://www.cppblog.com/cc/archive/2006/03/12/4045.html

http://bfzero.blog.hexun.com/8479899_d.html

不推荐这种叫法，就像上面说的，这种称呼方法更容易让人混淆。

因此，还是把声明类似于：char * const p; 之类的指针，称呼之为“常量指针”比较好。毕竟，这个叫起来更习惯一些。（《C专家编程》，传说中的鱼书，是一本相当权威的C语言学习参考书，我还是相信权威，还有就是依自己的习惯。）

喜欢这篇文章吗?

请订阅本站 RSS feed 或

作者：荒野无灯
出处：Hacklog【荒野无灯weblog】

声明: 本站遵循署名-非商业性使用-相同方式共享 2.5 共享协议. 转载请注明转自Hacklog【荒野无灯weblog】

本文链接: http://ihacklog.com/?p=4176

随机日志

2011年03月16日 // GPG 校验签名出错 NO_PUBKEY的解决办法 (5)
2010年11月26日 // jQ表格插件推荐：jQgrid (6)
2011年12月20日 // Hacklog Remote Attachment Upyun(又拍云版) v1.2.6 (39)
2009年11月28日 // ucenter应用开发笔记之通信篇 (2)
2008年12月19日 // 荒野无灯——叶延滨 (0)
2011年11月20日 // 成功将博客所有附件转移到远程服务器~~感谢蓝冰提供空间 (40)

硬盘整数分区计算工具

荒野无灯 — Fri, 15 Oct 2010 20:40:49 +0000

前天帮寝室小则装系统，把他的全盘格了，重新分区，他说要整数分区，总不是每次都拿计算器来算吧？
于是写了这么个小工具来计算整数分区的。用C语言编写，为了避免有童鞋打开时出现找不到msvcr100.dll文件的情况，采用的静态编译，因此体积较大。

工具下载：注意：该页面嵌入了下载文件，请访问该页面下载该文件。

有图有真相，看下分区效果：
共四个分区，前三个为整数分区，分别是 50GB , 100 GB , 100 GB 的：

关于算法，我这里引用下 slyar童鞋的说明：

对于FAT32格式：

应分配MB数=(分区GB数－1)×4+1024×分区GB数

也就是说，如果你要在FAT32格式的硬盘上分出一个10 GB的硬盘，那么：

你应该分配的MB数=(10-1)×4+1024×10=10276 MB

这样你就可以得到整数的10 GB分区了。

对于NTFS格式：

硬盘一般有255磁头，63扇区，故每柱面大小为：

512byte x 255 x 63＝8225280bytes ＝7.84423828125 MB

如果要分10 GB,那么要10×1024 MB=10240 MB

需要柱面数为10240÷7.84423828125=1305.416744475568004979769685652

取整数既为1306个柱面

应分MB数为1306×7.84423828125=10244.5751953125 MB

不管小数点后面几位都进1，也就是10245 MB，系统也就认为是10.00 GB了。

喜欢这篇文章吗?

请订阅本站 RSS feed 或

作者：荒野无灯
出处：Hacklog【荒野无灯weblog】

声明: 本站遵循署名-非商业性使用-相同方式共享 2.5 共享协议. 转载请注明转自Hacklog【荒野无灯weblog】

本文链接: http://ihacklog.com/?p=4158

随机日志

2011年07月11日 // NetBeans IDE 7 中使用英文字体中文变方块的解决办法 (4)
2010年11月12日 // 硬盘安装Win7[转] (8)
2008年12月24日 // 一個人的天空很藍蓝的有点忧郁—–by1987102500 (0)
2010年06月20日 // 心愿——分享一首好听的校园歌曲 (8)
2008年12月25日 // Discuz中的分页函数 (0)
2008年12月31日 // 基础补习：PHP易混淆函数的区分 (0)

vsftpd.log 中文显示为问号?的解决办法

荒野无灯 — Thu, 23 Sep 2010 10:41:48 +0000

查看了下vsftpd.log的源码，发现是其代码本身没有考虑到多字节字符问题。
为了确保安全，vsftpd把所有不可打印字符全部替换为了? .在替换时没有考虑到多字节字符，于是导致杯具的发生。见：
logging.c 153 vsf_log_do_log_to_file
str.c 671 str_replace_unprintable
sysutil.c 922 vsf_sysutil_isprint

经在ubuntu 10.04 server 和desktop下测试，按以下方法修改不能登录成功，但是，如果手动安装pam 再编译，则能够登录成功。但是，手动编译安装pam后，无论是server还是desktop版都不能登录系统了。
在ubuntu 10.04 server 和desktop下，
如果直接make && make install ,这时，ldd vsftpd 会发现没有加载pam.
如果果手动安装pam 再编译,再直接make && make install ,ldd vsftpd 会发现pam已经加载。不知道这是什么原因。

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

static void
vsf_log_do_log_to_file(int fd, struct mystr* p_str)
{
if (!tunable_no_log_lock)
{
int retval = vsf_sysutil_lock_file_write(fd);
if (vsf_sysutil_retval_is_error(retval))
{
return;
}
}
str_replace_unprintable(p_str, '?'); //这里便是导致不能显示中文的替换啦！
str_append_char(p_str, '\n');
/* Ignore write failure; maybe the disk filled etc. */
(void) str_write_loop(p_str, fd);
if (!tunable_no_log_lock)
{
vsf_sysutil_unlock_file(fd);
}
}

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

//如果字符是不可打印的，则将之替换为new_char
void
str_replace_unprintable(struct mystr* p_str, char new_char)
{
unsigned int i;
for (i=0; i < p_str->len; i++)
{
if (!vsf_sysutil_isprint(p_str->p_buf[i]))
{
p_str->p_buf[i] = new_char;
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

//判断是否可打印字符
//是则返回1
//不是则返回0
int
vsf_sysutil_isprint(int the_char)
{
/* From Solar - we know better than some libc's! Don't let any potential
* control chars through
*/
unsigned char uc = (unsigned char) the_char;
if (uc <= 31)
{
return 0;
}
if (uc == 177)
{
return 0;
}
if (uc >= 128 && uc <= 159)
{
return 0;
}
return isprint(the_char);
}

我的解决办法是用下面自定义的一个函数替换其vsf_sysutil_isprint 函数中的 isprint :
ps:utf-8 中三字节字符范围是： 0×80-0xbf , 0xe0-0xef .
按字节顺序： [0xe0-0xef] [0x80-0xbf] [0x80-0xbf]
即第一个字节是以1110开头的，第二，第三字节都是以10开头的。

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

//注：此函数写得并不好，只是简单地跳过中文字符。
int my_isprint(int the_char)
{
static int is_cjk=0;
static int is_cjk2=0;
static int first_time=1;

if(!first_time)
first_time=0;

unsigned char uc=(unsigned char ) the_char;
if(uc <= 31 )
return 0;
if(uc == 177)
return 0;
if(uc >=128 && uc <=159 )
return 0;

if( (uc >= 0xe0 && uc <=0xef ) && ( 0xE == ((unsigned char) uc>>4 ) ) )
is_cjk=1;
if( (uc >= 0x80 && uc <=0xbf ) && is_cjk && ( 0x2 ==( (unsigned char) uc>>6 ) ) )
is_cjk2=1;
if(first_time && is_cjk )
return 1;
if(!first_time && is_cjk && is_cjk2 )
return 1;

return isprint(the_char);
}

更简单的解决办法是，将logging.c中第163行的： str_replace_unprintable(p_str, ‘?’); 注释掉。(不过，这样可能引发不安全的因素！)

1	// str_replace_unprintable(p_str, '?');

修改代码前与修改代码后的对比（图中显示？号的是修改代码前的log ）：

其它的解决办法：
解決 vsftpd Log檔亂碼的替代方式

vsftpd的log檔有問題~ 老是把中文顯現為?
但是記載在 messages裡面是正常的

所以我先在 vsftpd.conf中設定
syslog_enable=YES

讓log寫到messages裡面

然後寫二個小程式，丟到 /usr/local/bin 下面，讓大家都能用
還算滿好用的~ 寫shell部份也可至SHELL程式區討論

程式一
#!/bin/sh
echo “查詢FTP的LOG檔”
grep vsftpd /var/log/messages | grep Client

程式二
#!/bin/sh
echo “查詢FTP的LOG檔”
echo “輸入欲查詢使用者名稱”
echo “INPUT USER NAME”
read username
grep vsftpd /var/log/messages | grep Client |grep $username

喜欢这篇文章吗?

请订阅本站 RSS feed 或

作者：荒野无灯
出处：Hacklog【荒野无灯weblog】

声明: 本站遵循署名-非商业性使用-相同方式共享 2.5 共享协议. 转载请注明转自Hacklog【荒野无灯weblog】

本文链接: http://ihacklog.com/?p=4116

随机日志

2009年10月29日 // 给wordpress图片加上Highslide特效(修正代码) (30)
2011年06月6日 // PHP Manual for Vim (1)
2011年06月12日 // Most used CSS tricks (0)
2009年10月28日 // 忧伤还是快乐 (4)
2011年07月6日 // Yii连接mssql 数据库配置 (0)
2011年08月20日 // 原创插件：HB smilies (3)

桌面IE图标无法删除的解决办法及IE主页被劫持的修复

荒野无灯 — Thu, 17 Jun 2010 17:14:59 +0000

中招状况：
桌面ie图标删除不了，右键点击只有”属性“ 、打开等三个东东，没有删除、重命名什么的。
分别用VC 和 reg 写了解决这个讨厌鬼的东东：
VC版:
注意：该页面嵌入了下载文件，请访问该页面下载该文件。

reg版：
注意：该页面嵌入了下载文件，请访问该页面下载该文件。
PS：就在我刚才在更新日志时发现WP提示：”WordPress 3.0 版本可用！“ ，跑到官方去看了下，暂时还只放出了英文版的。已经不早了（其实是很早，哈哈晚上1点50几），得睡觉去了，明天再来更新。

相关技术文档：
关于VC注册表操作注册表，可以参考： http://hi.baidu.com/walfer/blog/item/c5a9cefd19754c44d6887dbb.html

使用注册项 (.reg) 文件添加、修改或删除注册表子项和值
http://support.microsoft.com/kb/310516/zh-cn

读写注册表 http://www.cppblog.com/kyelin/archive/2007/01/25/17998.html

wcslen函数～宽字符和C http://www.ieing.cn/html-85961-1.html

关于wcslen的一个错觉! http://www.daxue.in/read-htm-tid-1895-fpage-491.html

如何实现用于 Windows NT 的递归 RegDeleteKey http://support.microsoft.com/kb/142491/zh-cn

枚举注册表搜索病毒痕迹的实现思路 http://huaidan.org/archives/1666.html

VC删除文件，目录，设置隐藏属性 http://www.blogguy.cn/show-725-1.html

喜欢这篇文章吗?

请订阅本站 RSS feed 或

作者：荒野无灯
出处：Hacklog【荒野无灯weblog】

声明: 本站遵循署名-非商业性使用-相同方式共享 2.5 共享协议. 转载请注明转自Hacklog【荒野无灯weblog】

本文链接: http://ihacklog.com/?p=3920

Hacklog » c/c++

BlowFish 加密算法Bcrypt

分组密码(Block cypher)

初始化向量（IV）

填充

加密模式

分块大小

喜欢这篇文章吗?

随机日志

关于C语言的char类型是有符号还是无符号

喜欢这篇文章吗?

相关日志

Linux中gotoxy函数的一个实现

喜欢这篇文章吗?

相关日志

文本文件批量合并小工具

喜欢这篇文章吗?

相关日志

avast病毒库更新程序的改进

喜欢这篇文章吗?

随机日志

关于递归与迭代

喜欢这篇文章吗?

随机日志

常量指针和指针常量——令人蛋疼的两个词

喜欢这篇文章吗?

随机日志

硬盘整数分区计算工具

喜欢这篇文章吗?

随机日志

vsftpd.log 中文显示为问号?的解决办法

喜欢这篇文章吗?

随机日志

桌面IE图标无法删除的解决办法及IE主页被劫持的修复

喜欢这篇文章吗?

相关日志