pgp-s2k.c Source File (original) (raw)

35#include "px.h"

37static int

39 unsigned key_len)

40{

41 unsigned md_rlen;

43 unsigned preload;

44 unsigned remain;

50 preload = 0;

51 while (remain > 0)

52 {

55 if (preload)

56 {

57 memset(buf, 0, preload);

59 }

60 preload++;

65 if (remain > md_rlen)

66 {

67 memcpy(dst, buf, md_rlen);

68 dst += md_rlen;

69 remain -= md_rlen;

70 }

71 else

72 {

73 memcpy(dst, buf, remain);

74 remain = 0;

75 }

76 }

78 return 0;

79}

81static int

83{

84 unsigned md_rlen;

86 unsigned preload = 0;

88 unsigned remain;

92 dst = s2k->key;

94 while (remain > 0)

95 {

98 if (preload > 0)

99 {

100 memset(buf, 0, preload);

102 }

103 preload++;

104

108

109 if (remain > md_rlen)

110 {

111 memcpy(dst, buf, md_rlen);

112 remain -= md_rlen;

113 dst += md_rlen;

114 }

115 else

116 {

117 memcpy(dst, buf, remain);

118 remain = 0;

119 }

120 }

122 return 0;

123}

124

125static int

127 unsigned key_len)

128{

129 unsigned md_rlen;

132 unsigned preload = 0;

133 unsigned remain,

134 c,

135 curcnt,

136 count;

137

139

141

143 dst = s2k->key;

144 while (remain > 0)

145 {

147

148 if (preload)

149 {

150 memset(buf, 0, preload);

152 }

153 preload++;

154

158

159 while (curcnt < count)

160 {

163 else

164 c = count - curcnt;

166 curcnt += c;

167

168 if (curcnt + key_len < count)

169 c = key_len;

170 else if (curcnt < count)

171 c = count - curcnt;

172 else

173 break;

175 curcnt += c;

176 }

178

179 if (remain > md_rlen)

180 {

181 memcpy(dst, buf, md_rlen);

182 remain -= md_rlen;

183 dst += md_rlen;

184 }

185 else

186 {

187 memcpy(dst, buf, remain);

188 remain = 0;

189 }

190 }

192 return 0;

193}

194

195

196

197

198

199

200

201

202

203

204

205

206

207

210{

211 int iter;

212

213 if (count == -1)

214 return 96 + (rand_byte & 0x1F);

215

216 for (iter = 0; iter <= 255; iter++)

218 return iter;

219 return 255;

220}

221

222int

224{

225 int res = 0;

227

230

231 switch (s2k->mode)

232 {

234 break;

238 break;

245 break;

246 default:

248 }

249 return res;

250}

251

252int

254{

255 int res = 0;

256

259 switch (s2k->mode)

260 {

261 case 0:

262 break;

263 case 1:

265 break;

266 case 3:

268 if (res < 0)

269 break;

271 break;

272 default:

274 }

275 return res;

276}

277

278int

280{

281 int res;

283

287

289 if (res < 0)

290 return res;

291

292 switch (s2k->mode)

293 {

294 case 0:

296 break;

297 case 1:

299 break;

300 case 3:

302 break;

303 default:

305 }

307 return res;

308}

int pullf_read_fixed(PullFilter *src, int len, uint8 *dst)

static PgChecksumMode mode

int pgp_s2k_process(PGP_S2K *s2k, int cipher, const uint8 *key, int key_len)

static int calc_s2k_salted(PGP_S2K *s2k, PX_MD *md, const uint8 *key, unsigned key_len)

int pgp_s2k_fill(PGP_S2K *s2k, int mode, int digest_algo, int count)

int pgp_s2k_read(PullFilter *src, PGP_S2K *s2k)

static uint8 decide_s2k_iter(unsigned rand_byte, int count)

static int calc_s2k_simple(PGP_S2K *s2k, PX_MD *md, const uint8 *key, unsigned key_len)

static int calc_s2k_iter_salted(PGP_S2K *s2k, PX_MD *md, const uint8 *key, unsigned key_len)

int pgp_get_cipher_key_size(int code)

int pgp_load_digest(int code, PX_MD **res)

#define s2k_decode_count(cval)

bool pg_strong_random(void *buf, size_t len)

void px_memset(void *ptr, int c, size_t len)

#define PXE_PGP_BAD_S2K_MODE

#define px_md_finish(md, buf)

#define px_md_update(md, data, dlen)

#define PXE_PGP_UNSUPPORTED_CIPHER

#define px_md_result_size(md)