#include "postgres.h"
-#include "px.h"
#include "px-crypt.h"
+#include "px.h"
#ifdef __i386__
#define BF_ASM 0 /* 1 */
count = (BF_word) 1 << ((setting[4] - '0') * 10 + (setting[5] - '0'));
if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16))
{
- memset(data.binary.salt, 0, sizeof(data.binary.salt));
+ px_memset(data.binary.salt, 0, sizeof(data.binary.salt));
return NULL;
}
BF_swap(data.binary.salt, 4);
/* Overwrite the most obvious sensitive data we have on the stack. Note
* that this does not guarantee there's no sensitive data left on the
* stack and/or in registers; I'm not aware of portable code that does. */
- memset(&data, 0, sizeof(data));
+ px_memset(&data, 0, sizeof(data));
return output;
}
px_md_update(ctx, final, pl > MD5_SIZE ? MD5_SIZE : pl);
/* Don't leave anything around in vm they could use. */
- memset(final, 0, sizeof final);
+ px_memset(final, 0, sizeof final);
/* Then something really weird... */
for (i = strlen(pw); i; i >>= 1)
*p = '\0';
/* Don't leave anything around in vm they could use. */
- memset(final, 0, sizeof final);
+ px_memset(final, 0, sizeof final);
px_md_free(ctx1);
px_md_free(ctx);
#include <sys/time.h>
#include <time.h>
+#include "px.h"
#include "rijndael.h"
#include "sha2.h"
#include "fortuna.h"
memcpy(&tmp, ctx, sizeof(*ctx));
SHA256_Final(dst, &tmp);
- memset(&tmp, 0, sizeof(tmp));
+ px_memset(&tmp, 0, sizeof(tmp));
}
/*
if (ok)
memcpy(last, &tv, sizeof(tv));
- memset(&tv, 0, sizeof(tv));
+ px_memset(&tv, 0, sizeof(tv));
return ok;
}
/* use new key */
ciph_init(&st->ciph, st->key, BLOCK);
- memset(&key_md, 0, sizeof(key_md));
- memset(buf, 0, BLOCK);
+ px_memset(&key_md, 0, sizeof(key_md));
+ px_memset(buf, 0, BLOCK);
}
/*
if (pos == 0)
st->pool0_bytes += len;
- memset(hash, 0, BLOCK);
- memset(&md, 0, sizeof(md));
+ px_memset(hash, 0, BLOCK);
+ px_memset(&md, 0, sizeof(md));
}
/*
encrypt_counter(st, buf + CIPH_BLOCK);
md_update(&st->pool[i], buf, BLOCK);
}
- memset(buf, 0, BLOCK);
+ px_memset(buf, 0, BLOCK);
/* Hide the key. */
rekey(st);
{
SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
- memset(ctx, 0, sizeof(*ctx));
+ px_memset(ctx, 0, sizeof(*ctx));
px_free(ctx);
px_free(h);
}
{
SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
- memset(ctx, 0, sizeof(*ctx));
+ px_memset(ctx, 0, sizeof(*ctx));
px_free(ctx);
px_free(h);
}
{
SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
- memset(ctx, 0, sizeof(*ctx));
+ px_memset(ctx, 0, sizeof(*ctx));
px_free(ctx);
px_free(h);
}
{
SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
- memset(ctx, 0, sizeof(*ctx));
+ px_memset(ctx, 0, sizeof(*ctx));
px_free(ctx);
px_free(h);
}
{
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
- memset(ctx, 0, sizeof(*ctx));
+ px_memset(ctx, 0, sizeof(*ctx));
px_free(ctx);
px_free(h);
}
{
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
- memset(ctx, 0, sizeof(*ctx));
+ px_memset(ctx, 0, sizeof(*ctx));
px_free(ctx);
px_free(h);
}
if (cx)
{
- memset(cx, 0, sizeof *cx);
+ px_memset(cx, 0, sizeof *cx);
px_free(cx);
}
px_free(c);
skip = buf[0] >= SYSTEM_RESEED_CHANCE;
}
/* clear 1 byte */
- memset(buf, 0, sizeof(buf));
+ px_memset(buf, 0, sizeof(buf));
if (skip)
return;
fortuna_add_entropy(buf, n);
seed_time = t;
- memset(buf, 0, sizeof(buf));
+ px_memset(buf, 0, sizeof(buf));
}
int
{
if (mbuf->own_data)
{
- memset(mbuf->data, 0, mbuf->buf_end - mbuf->data);
+ px_memset(mbuf->data, 0, mbuf->buf_end - mbuf->data);
px_free(mbuf->data);
}
px_free(mbuf);
if (pf->buf)
{
- memset(pf->buf, 0, pf->buflen);
+ px_memset(pf->buf, 0, pf->buflen);
px_free(pf->buf);
}
- memset(pf, 0, sizeof(*pf));
+ px_memset(pf, 0, sizeof(*pf));
px_free(pf);
}
if (res < 0)
{
/* so the caller must clear only on success */
- memset(tmpbuf, 0, total);
+ px_memset(tmpbuf, 0, total);
return res;
}
if (res == 0)
if (mp->buf)
{
- memset(mp->buf, 0, mp->block_size);
+ px_memset(mp->buf, 0, mp->block_size);
px_free(mp->buf);
}
- memset(mp, 0, sizeof(*mp));
+ px_memset(mp, 0, sizeof(*mp));
px_free(mp);
}
static int
EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
{
- memset(ctx, 0, sizeof(*ctx));
+ px_memset(ctx, 0, sizeof(*ctx));
return 1;
}
{
ossldata *od = (ossldata *) c->ptr;
- memset(od, 0, sizeof(*od));
+ px_memset(od, 0, sizeof(*od));
px_free(od);
px_free(c);
}
pgp_cfb_free(PGP_CFB *ctx)
{
px_cipher_free(ctx->ciph);
- memset(ctx, 0, sizeof(*ctx));
+ px_memset(ctx, 0, sizeof(*ctx));
px_free(ctx);
}
struct ZipStat *st = priv;
deflateEnd(&st->stream);
- memset(st, 0, sizeof(*st));
+ px_memset(st, 0, sizeof(*st));
px_free(st);
}
struct DecomprData *dec = priv;
inflateEnd(&dec->stream);
- memset(dec, 0, sizeof(*dec));
+ px_memset(dec, 0, sizeof(*dec));
px_free(dec);
}
{
struct PktData *pkt = priv;
- memset(pkt, 0, sizeof(*pkt));
+ px_memset(pkt, 0, sizeof(*pkt));
px_free(pkt);
}
if (res != len + 2)
{
px_debug("prefix_init: short read");
- memset(tmpbuf, 0, sizeof(tmpbuf));
+ px_memset(tmpbuf, 0, sizeof(tmpbuf));
return PXE_PGP_CORRUPT_DATA;
}
*/
ctx->corrupt_prefix = 1;
}
- memset(tmpbuf, 0, sizeof(tmpbuf));
+ px_memset(tmpbuf, 0, sizeof(tmpbuf));
return 0;
}
*/
px_md_finish(ctx->mdc_ctx, hash);
res = memcmp(hash, *data_p, 20);
- memset(hash, 0, 20);
- memset(tmpbuf, 0, sizeof(tmpbuf));
+ px_memset(hash, 0, 20);
+ px_memset(tmpbuf, 0, sizeof(tmpbuf));
if (res != 0)
{
px_debug("mdc_finish: mdc failed");
px_md_update(st->ctx->mdc_ctx, st->mdc_buf, 2);
px_md_finish(st->ctx->mdc_ctx, hash);
res = memcmp(hash, st->mdc_buf + 2, 20);
- memset(hash, 0, 20);
+ px_memset(hash, 0, 20);
if (res)
{
px_debug("mdcbuf_finish: MDC does not match");
px_md_free(st->ctx->mdc_ctx);
st->ctx->mdc_ctx = NULL;
- memset(st, 0, sizeof(*st));
+ px_memset(st, 0, sizeof(*st));
px_free(st);
}
res = decrypt_key(ctx, p, res);
}
- memset(tmpbuf, 0, sizeof(tmpbuf));
+ px_memset(tmpbuf, 0, sizeof(tmpbuf));
return res;
}
if (res < 0)
return res;
}
+ px_memset(tmpbuf, 0, sizeof(tmpbuf));
return 0;
}
px_debug("parse_literal_data: unexpected eof");
return PXE_PGP_CORRUPT_DATA;
}
- memset(tmpbuf, 0, 4);
+ px_memset(tmpbuf, 0, 4);
/* check if text */
if (ctx->text_mode)
px_md_finish(md, pkt + 2);
res = pushf_write(dst, pkt, 2 + MDC_DIGEST_LEN);
- memset(pkt, 0, 2 + MDC_DIGEST_LEN);
+ px_memset(pkt, 0, 2 + MDC_DIGEST_LEN);
return res;
}
{
struct EncStat *st = priv;
- memset(st, 0, sizeof(*st));
+ px_memset(st, 0, sizeof(*st));
px_free(st);
}
{
struct PktStreamStat *st = priv;
- memset(st, 0, sizeof(*st));
+ px_memset(st, 0, sizeof(*st));
px_free(st);
}
prefix[bs + 1] = prefix[bs - 1];
res = pushf_write(dst, prefix, bs + 2);
- memset(prefix, 0, bs + 2);
+ px_memset(prefix, 0, bs + 2);
return res < 0 ? res : 0;
}
if (res >= 0)
res = pushf_write(dst, pkt, pktlen);
- memset(pkt, 0, pktlen);
+ px_memset(pkt, 0, pktlen);
return res;
}
{
if (mpi == NULL)
return 0;
- memset(mpi, 0, sizeof(*mpi) + mpi->bytes);
+ px_memset(mpi, 0, sizeof(*mpi) + mpi->bytes);
px_free(mpi);
return 0;
}
px_add_entropy(sha1, 20);
- memset(sha1, 0, 20);
+ px_memset(sha1, 0, 20);
}
/*
add_block_entropy(md, data3);
px_md_free(md);
- memset(rnd, 0, sizeof(rnd));
+ px_memset(rnd, 0, sizeof(rnd));
}
/*
static void
clear_and_pfree(text *p)
{
- memset(p, 0, VARSIZE(p));
+ px_memset(p, 0, VARSIZE(p));
pfree(p);
}
if (res < 0)
{
- memset(buf, 0, res_len);
+ px_memset(buf, 0, res_len);
px_free(buf);
return res;
}
if (padded)
{
- memset(padded, 0, full_bytes);
+ px_memset(padded, 0, full_bytes);
px_free(padded);
}
- memset(secmsg, 0, klen + 3);
+ px_memset(secmsg, 0, klen + 3);
px_free(secmsg);
if (res >= 0)
pgp_mpi_free(pk->sec.dsa.x);
break;
}
- memset(pk, 0, sizeof(*pk));
+ px_memset(pk, 0, sizeof(*pk));
px_free(pk);
}
px_md_free(md);
memcpy(pk->key_id, hash + 12, 8);
- memset(hash, 0, 20);
+ px_memset(hash, 0, 20);
return 0;
}
res = PXE_PGP_KEYPKT_CORRUPT;
}
err:
- memset(got_sha1, 0, 20);
- memset(my_sha1, 0, 20);
+ px_memset(got_sha1, 0, 20);
+ px_memset(my_sha1, 0, 20);
return res;
}
remain = 0;
}
}
+ px_memset(buf, 0, sizeof(buf));
return 0;
}
remain = 0;
}
}
+ px_memset(buf, 0, sizeof(buf));
return 0;
}
remain = 0;
}
}
+ px_memset(buf, 0, sizeof(buf));
return 0;
}
{
if (ctx->pub_key)
pgp_key_free(ctx->pub_key);
- memset(ctx, 0, sizeof *ctx);
+ px_memset(ctx, 0, sizeof *ctx);
px_free(ctx);
return 0;
}
return res;
p = g->gen(rounds, rbuf, g->input_len, buf, PX_MAX_SALT_LEN);
- memset(rbuf, 0, sizeof(rbuf));
+ px_memset(rbuf, 0, sizeof(rbuf));
if (p == NULL)
return PXE_BAD_SALT_ROUNDS;
h->p.opad[i] = keybuf[i] ^ HMAC_OPAD;
}
- memset(keybuf, 0, bs);
+ px_memset(keybuf, 0, bs);
px_free(keybuf);
px_md_update(md, h->p.ipad, bs);
px_md_update(md, buf, hlen);
px_md_finish(md, dst);
- memset(buf, 0, hlen);
+ px_memset(buf, 0, hlen);
px_free(buf);
}
bs = px_md_block_size(h->md);
px_md_free(h->md);
- memset(h->p.ipad, 0, bs);
- memset(h->p.opad, 0, bs);
+ px_memset(h->p.ipad, 0, bs);
+ px_memset(h->p.opad, 0, bs);
px_free(h->p.ipad);
px_free(h->p.opad);
px_free(h);
return "Bad error code";
}
+/* memset that must not be optimized away */
+void
+px_memset(void *ptr, int c, size_t len)
+{
+ memset(ptr, c, len);
+}
const char *
px_resolve_alias(const PX_Alias *list, const char *name)
{
if (cx->cipher)
px_cipher_free(cx->cipher);
- memset(cx, 0, sizeof(*cx));
+ px_memset(cx, 0, sizeof(*cx));
px_free(cx);
}
const char *px_resolve_alias(const PX_Alias *aliases, const char *name);
void px_set_debug_handler(void (*handler) (const char *));
+void px_memset(void *ptr, int c, size_t len);
#ifdef PX_DEBUG
void px_debug(const char *fmt,...);
#include <sys/param.h>
+#include "px.h"
#include "sha2.h"
/*
}
/* Clean up state data: */
- memset(context, 0, sizeof(*context));
+ px_memset(context, 0, sizeof(*context));
}
}
/* Zero out state data */
- memset(context, 0, sizeof(*context));
+ px_memset(context, 0, sizeof(*context));
}
}
/* Zero out state data */
- memset(context, 0, sizeof(*context));
+ px_memset(context, 0, sizeof(*context));
}
/*** SHA-224: *********************************************************/
}
/* Clean up state data: */
- memset(context, 0, sizeof(*context));
+ px_memset(context, 0, sizeof(*context));
}
projects / postgresql.git / commitdiff