int gost_digest_cleanup(EVP_MD_CTX *ctx) { if (EVP_MD_CTX_md_data(ctx)) memset(EVP_MD_CTX_md_data(ctx), 0, sizeof(struct ossl_gost_digest_ctx)); return 1; }
static int gost_digest_cleanup(EVP_MD_CTX *ctx) { if (EVP_MD_CTX_md_data(ctx)) memset(EVP_MD_CTX_md_data(ctx), 0x00, sizeof(gost2012_hash_ctx)); return 1; }
static int gost_digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from) { if (EVP_MD_CTX_md_data(to) && EVP_MD_CTX_md_data(from)) memcpy(EVP_MD_CTX_md_data(to), EVP_MD_CTX_md_data(from), sizeof(gost2012_hash_ctx)); return 1; }
int gost_digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from) { struct ossl_gost_digest_ctx *md_ctx = EVP_MD_CTX_md_data(to); if (EVP_MD_CTX_md_data(to) && EVP_MD_CTX_md_data(from)) { memcpy(EVP_MD_CTX_md_data(to), EVP_MD_CTX_md_data(from), sizeof(struct ossl_gost_digest_ctx)); md_ctx->dctx.cipher_ctx = &(md_ctx->cctx); } return 1; }
static int test_mdc2(void) { int testresult = 0; unsigned char md[MDC2_DIGEST_LENGTH]; EVP_MD_CTX *c; static char text[] = "Now is the time for all "; size_t tlen = strlen(text); # ifdef CHARSET_EBCDIC ebcdic2ascii(text, text, tlen); # endif c = EVP_MD_CTX_new(); if (!TEST_ptr(c) || !TEST_true(EVP_DigestInit_ex(c, EVP_mdc2(), NULL)) || !TEST_true(EVP_DigestUpdate(c, (unsigned char *)text, tlen)) || !TEST_true(EVP_DigestFinal_ex(c, &(md[0]), NULL)) || !TEST_mem_eq(md, MDC2_DIGEST_LENGTH, pad1, MDC2_DIGEST_LENGTH) || !TEST_true(EVP_DigestInit_ex(c, EVP_mdc2(), NULL))) goto end; /* FIXME: use a ctl function? */ ((MDC2_CTX *)EVP_MD_CTX_md_data(c))->pad_type = 2; if (!TEST_true(EVP_DigestUpdate(c, (unsigned char *)text, tlen)) || !TEST_true(EVP_DigestFinal_ex(c, &(md[0]), NULL)) || !TEST_mem_eq(md, MDC2_DIGEST_LENGTH, pad2, MDC2_DIGEST_LENGTH)) goto end; testresult = 1; end: EVP_MD_CTX_free(c); return testresult; }
static int test_sha1_init(EVP_MD_CTX *ctx) { # ifdef TEST_ENG_OPENSSL_SHA_P_INIT fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_init() called\n"); # endif return SHA1_Init(EVP_MD_CTX_md_data(ctx)); }
static int test_sha1_update(EVP_MD_CTX *ctx, const void *data, size_t count) { # ifdef TEST_ENG_OPENSSL_SHA_P_UPDATE fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_update() called\n"); # endif return SHA1_Update(EVP_MD_CTX_md_data(ctx), data, count); }
static int test_sha1_final(EVP_MD_CTX *ctx, unsigned char *md) { # ifdef TEST_ENG_OPENSSL_SHA_P_FINAL fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_final() called\n"); # endif return SHA1_Final(md, EVP_MD_CTX_md_data(ctx)); }
static int init(EVP_MD_CTX *ctx) { struct md5_sha1_ctx *mctx = EVP_MD_CTX_md_data(ctx); if (!MD5_Init(&mctx->md5)) return 0; return SHA1_Init(&mctx->sha1); }
static int digest_init(EVP_MD_CTX *ctx) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); const struct digest_data_st *digest_d = get_digest_data(EVP_MD_CTX_type(ctx)); if (digest_ctx->init == 0 && (digest_ctx->cfd = open("/dev/crypto", O_RDWR, 0)) < 0) { SYSerr(SYS_F_OPEN, errno); return 0; } digest_ctx->init = 1; memset(&digest_ctx->sess, 0, sizeof(digest_ctx->sess)); digest_ctx->sess.mac = digest_d->devcryptoid; if (ioctl(digest_ctx->cfd, CIOCGSESSION, &digest_ctx->sess) < 0) { SYSerr(SYS_F_IOCTL, errno); close(digest_ctx->cfd); return 0; } return 1; }
static int update(EVP_MD_CTX *ctx, const void *data, size_t count) { struct md5_sha1_ctx *mctx = EVP_MD_CTX_md_data(ctx); if (!MD5_Update(&mctx->md5, data, count)) return 0; return SHA1_Update(&mctx->sha1, data, count); }
int gost_digest_init(EVP_MD_CTX *ctx) { struct ossl_gost_digest_ctx *c = EVP_MD_CTX_md_data(ctx); memset(&(c->dctx), 0, sizeof(gost_hash_ctx)); gost_init(&(c->cctx), &GostR3411_94_CryptoProParamSet); c->dctx.cipher_ctx = &(c->cctx); return 1; }
static int digest_cleanup(EVP_MD_CTX *ctx) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); if (digest_ctx == NULL) return 1; return clean_devcrypto_session(&digest_ctx->sess); }
static int digest_cleanup(EVP_MD_CTX *ctx) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); if (close(digest_ctx->cfd) < 0) { SYSerr(SYS_F_CLOSE, errno); return 0; } return 1; }
static int digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from) { struct digest_ctx *digest_from = (struct digest_ctx *)EVP_MD_CTX_md_data(from); struct digest_ctx *digest_to = (struct digest_ctx *)EVP_MD_CTX_md_data(to); struct cphash_op cphash; if (digest_from == NULL || digest_from->init_called != 1) return 1; if (!digest_init(to)) { SYSerr(SYS_F_IOCTL, errno); return 0; } cphash.src_ses = digest_from->sess.ses; cphash.dst_ses = digest_to->sess.ses; if (ioctl(cfd, CIOCCPHASH, &cphash) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } return 1; }
static int digest_update(EVP_MD_CTX *ctx, const void *data, size_t count) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); if (count == 0) return 1; if (digest_op(digest_ctx, data, count, NULL, COP_FLAG_UPDATE) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } return 1; }
int main(int argc, char *argv[]) { int ret = 0; unsigned char md[MDC2_DIGEST_LENGTH]; int i; EVP_MD_CTX *c; static char *text = "Now is the time for all "; # ifdef CHARSET_EBCDIC ebcdic2ascii(text, text, strlen(text)); # endif c = EVP_MD_CTX_new(); EVP_DigestInit_ex(c, EVP_mdc2(), NULL); EVP_DigestUpdate(c, (unsigned char *)text, strlen(text)); EVP_DigestFinal_ex(c, &(md[0]), NULL); if (memcmp(md, pad1, MDC2_DIGEST_LENGTH) != 0) { for (i = 0; i < MDC2_DIGEST_LENGTH; i++) printf("%02X", md[i]); printf(" <- generated\n"); for (i = 0; i < MDC2_DIGEST_LENGTH; i++) printf("%02X", pad1[i]); printf(" <- correct\n"); ret = 1; } else printf("pad1 - ok\n"); EVP_DigestInit_ex(c, EVP_mdc2(), NULL); /* FIXME: use a ctl function? */ ((MDC2_CTX *)EVP_MD_CTX_md_data(c))->pad_type = 2; EVP_DigestUpdate(c, (unsigned char *)text, strlen(text)); EVP_DigestFinal_ex(c, &(md[0]), NULL); if (memcmp(md, pad2, MDC2_DIGEST_LENGTH) != 0) { for (i = 0; i < MDC2_DIGEST_LENGTH; i++) printf("%02X", md[i]); printf(" <- generated\n"); for (i = 0; i < MDC2_DIGEST_LENGTH; i++) printf("%02X", pad2[i]); printf(" <- correct\n"); ret = 1; } else printf("pad2 - ok\n"); EVP_MD_CTX_free(c); EXIT(ret); }
static int digest_final(EVP_MD_CTX *ctx, unsigned char *md) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); if (digest_op(digest_ctx, NULL, 0, md, COP_FLAG_FINAL) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } if (ioctl(digest_ctx->cfd, CIOCFSESSION, &digest_ctx->sess) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } return 1; }
static int sig_in(BIO *b) { BIO_OK_CTX *ctx; EVP_MD_CTX *md; unsigned char tmp[EVP_MAX_MD_SIZE]; int ret = 0; const EVP_MD *digest; int md_size; void *md_data; ctx = BIO_get_data(b); md = ctx->md; digest = EVP_MD_CTX_md(md); md_size = EVP_MD_size(digest); md_data = EVP_MD_CTX_md_data(md); if ((int)(ctx->buf_len - ctx->buf_off) < 2 * md_size) return 1; if (!EVP_DigestInit_ex(md, digest, NULL)) goto berr; memcpy(md_data, &(ctx->buf[ctx->buf_off]), md_size); longswap(md_data, md_size); ctx->buf_off += md_size; if (!EVP_DigestUpdate(md, WELLKNOWN, strlen(WELLKNOWN))) goto berr; if (!EVP_DigestFinal_ex(md, tmp, NULL)) goto berr; ret = memcmp(&(ctx->buf[ctx->buf_off]), tmp, md_size) == 0; ctx->buf_off += md_size; if (ret == 1) { ctx->sigio = 0; if (ctx->buf_len != ctx->buf_off) { memmove(ctx->buf, &(ctx->buf[ctx->buf_off]), ctx->buf_len - ctx->buf_off); } ctx->buf_len -= ctx->buf_off; ctx->buf_off = 0; } else { ctx->cont = 0; } return 1; berr: BIO_clear_retry_flags(b); return 0; }
static int digest_init(EVP_MD_CTX *ctx) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); const struct digest_data_st *digest_d = get_digest_data(EVP_MD_CTX_type(ctx)); digest_ctx->init_called = 1; memset(&digest_ctx->sess, 0, sizeof(digest_ctx->sess)); digest_ctx->sess.mac = digest_d->devcryptoid; if (ioctl(cfd, CIOCGSESSION, &digest_ctx->sess) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } return 1; }
static int digest_final(EVP_MD_CTX *ctx, unsigned char *md) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); if (md == NULL || digest_ctx == NULL) return 0; if (EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT)) { memcpy(md, digest_ctx->digest_res, EVP_MD_CTX_size(ctx)); } else if (digest_op(digest_ctx, NULL, 0, md, COP_FLAG_FINAL) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } return 1; }
static int sig_out(BIO *b) { BIO_OK_CTX *ctx; EVP_MD_CTX *md; const EVP_MD *digest; int md_size; void *md_data; ctx = BIO_get_data(b); md = ctx->md; digest = EVP_MD_CTX_md(md); md_size = EVP_MD_size(digest); md_data = EVP_MD_CTX_md_data(md); if (ctx->buf_len + 2 * md_size > OK_BLOCK_SIZE) return 1; if (!EVP_DigestInit_ex(md, digest, NULL)) goto berr; /* * FIXME: there's absolutely no guarantee this makes any sense at all, * particularly now EVP_MD_CTX has been restructured. */ if (RAND_bytes(md_data, md_size) <= 0) goto berr; memcpy(&(ctx->buf[ctx->buf_len]), md_data, md_size); longswap(&(ctx->buf[ctx->buf_len]), md_size); ctx->buf_len += md_size; if (!EVP_DigestUpdate(md, WELLKNOWN, strlen(WELLKNOWN))) goto berr; if (!EVP_DigestFinal_ex(md, &(ctx->buf[ctx->buf_len]), NULL)) goto berr; ctx->buf_len += md_size; ctx->blockout = 1; ctx->sigio = 0; return 1; berr: BIO_clear_retry_flags(b); return 0; }
static int digest_update(EVP_MD_CTX *ctx, const void *data, size_t count) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); if (count == 0) return 1; if (digest_ctx == NULL) return 0; if (EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT)) { if (digest_op(digest_ctx, data, count, digest_ctx->digest_res, 0) >= 0) return 1; } else if (digest_op(digest_ctx, data, count, NULL, COP_FLAG_UPDATE) >= 0) { return 1; } SYSerr(SYS_F_IOCTL, errno); return 0; }
static int gost_digest_update(EVP_MD_CTX *ctx, const void *data, size_t count) { gost2012_hash_block((gost2012_hash_ctx *) EVP_MD_CTX_md_data(ctx), data, count); return 1; }
if (!MD5_Init(&mctx->md5)) return 0; return SHA1_Init(&mctx->sha1); } static int update(EVP_MD_CTX *ctx, const void *data, size_t count) { struct md5_sha1_ctx *mctx = EVP_MD_CTX_md_data(ctx); if (!MD5_Update(&mctx->md5, data, count)) return 0; return SHA1_Update(&mctx->sha1, data, count); } static int final(EVP_MD_CTX *ctx, unsigned char *md) { struct md5_sha1_ctx *mctx = EVP_MD_CTX_md_data(ctx); if (!MD5_Final(md, &mctx->md5)) return 0; return SHA1_Final(md + MD5_DIGEST_LENGTH, &mctx->sha1); } static int ctrl(EVP_MD_CTX *ctx, int cmd, int mslen, void *ms) { unsigned char padtmp[48]; unsigned char md5tmp[MD5_DIGEST_LENGTH]; unsigned char sha1tmp[SHA_DIGEST_LENGTH]; struct md5_sha1_ctx *mctx = EVP_MD_CTX_md_data(ctx); if (cmd != EVP_CTRL_SSL3_MASTER_SECRET) return 0;
static int init(EVP_MD_CTX *ctx) { return WHIRLPOOL_Init(EVP_MD_CTX_md_data(ctx)); }
static int gost_digest_init256(EVP_MD_CTX *ctx) { init_gost2012_hash_ctx((gost2012_hash_ctx *) EVP_MD_CTX_md_data(ctx), 256); return 1; }
static int init(EVP_MD_CTX *ctx) { return MD5_Init(EVP_MD_CTX_md_data(ctx)); }
static int update(EVP_MD_CTX *ctx, const void *data, size_t count) { return MD5_Update(EVP_MD_CTX_md_data(ctx), data, count); }
static int gost_digest_final(EVP_MD_CTX *ctx, unsigned char *md) { gost2012_finish_hash((gost2012_hash_ctx *) EVP_MD_CTX_md_data(ctx), md); return 1; }