scram-common.c File Reference (original) (raw)

212{

216 char *result;

217 char *p;

218 int maxlen;

219 int encoded_salt_len;

220 int encoded_stored_len;

221 int encoded_server_len;

222 int encoded_result;

223

224

226

228

229

232 salted_password, errstr) < 0 ||

234 stored_key, errstr) < 0 ||

235 scram_H(stored_key, hash_type, key_length,

236 stored_key, errstr) < 0 ||

238 server_key, errstr) < 0)

239 {

240

241#ifdef FRONTEND

242 return NULL;

243#else

244 elog(ERROR, "could not calculate stored key and server key: %s",

245 *errstr);

246#endif

247 }

248

249

250

251

252

253

257

258 maxlen = strlen("SCRAM-SHA-256") + 1

259 + 10 + 1

260 + encoded_salt_len + 1

261 + encoded_stored_len + 1

262 + encoded_server_len + 1;

263

264#ifdef FRONTEND

265 result = malloc(maxlen);

266 if (!result)

267 {

268 *errstr = _("out of memory");

269 return NULL;

270 }

271#else

272 result = palloc(maxlen);

273#endif

274

276

277

278 encoded_result = pg_b64_encode(salt, saltlen, p, encoded_salt_len);

279 if (encoded_result < 0)

280 {

281 *errstr = _("could not encode salt");

282#ifdef FRONTEND

283 free(result);

284 return NULL;

285#else

287#endif

288 }

289 p += encoded_result;

290 *(p++) = '$';

291

292

293 encoded_result = pg_b64_encode(stored_key, key_length, p,

294 encoded_stored_len);

295 if (encoded_result < 0)

296 {

297 *errstr = _("could not encode stored key");

298#ifdef FRONTEND

299 free(result);

300 return NULL;

301#else

303#endif

304 }

305

306 p += encoded_result;

307 *(p++) = ':';

308

309

310 encoded_result = pg_b64_encode(server_key, key_length, p,

311 encoded_server_len);

312 if (encoded_result < 0)

313 {

314 *errstr = _("could not encode server key");

315#ifdef FRONTEND

316 free(result);

317 return NULL;

318#else

320#endif

321 }

322

323 p += encoded_result;

324 *(p++) = '\0';

325

326 Assert(p - result <= maxlen);

327

328 return result;

329}

int pg_b64_enc_len(int srclen)

int pg_b64_encode(const uint8 *src, int len, char *dst, int dstlen)

Assert(PointerIsAligned(start, uint64))

int scram_ServerKey(const uint8 *salted_password, pg_cryptohash_type hash_type, int key_length, uint8 *result, const char **errstr)

int scram_SaltedPassword(const char *password, pg_cryptohash_type hash_type, int key_length, const uint8 *salt, int saltlen, int iterations, uint8 *result, const char **errstr)

int scram_ClientKey(const uint8 *salted_password, pg_cryptohash_type hash_type, int key_length, uint8 *result, const char **errstr)

int scram_H(const uint8 *input, pg_cryptohash_type hash_type, int key_length, uint8 *result, const char **errstr)

#define SCRAM_MAX_KEY_LEN