* ext/digest/digest.c (rb_digest_base_alloc,
rb_digest_base_equal): Simplify the equality check and just compare resulted digests since state-level equality should not be significant. * ext/digest/digest.h: Ditto. * ext/digest/*/*.[ch]: Ditto. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11131 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
parent
76f721470b
commit
945a76d97b
11
ChangeLog
11
ChangeLog
@ -1,3 +1,14 @@
|
|||||||
|
Wed Oct 11 21:36:47 2006 Akinori MUSHA <knu@iDaemons.org>
|
||||||
|
|
||||||
|
* ext/digest/digest.c (rb_digest_base_alloc,
|
||||||
|
rb_digest_base_equal): Simplify the equality check and just
|
||||||
|
compare resulted digests since state-level equality should
|
||||||
|
not be so significant.
|
||||||
|
|
||||||
|
* ext/digest/digest.h: Ditto.
|
||||||
|
|
||||||
|
* ext/digest/*/*.[ch]: Ditto.
|
||||||
|
|
||||||
Wed Oct 11 17:11:03 2006 Yukihiro Matsumoto <matz@ruby-lang.org>
|
Wed Oct 11 17:11:03 2006 Yukihiro Matsumoto <matz@ruby-lang.org>
|
||||||
|
|
||||||
* eval.c (rb_obj_define_method): add half boiled RDoc document.
|
* eval.c (rb_obj_define_method): add half boiled RDoc document.
|
||||||
|
@ -151,8 +151,7 @@ rb_digest_base_alloc(VALUE klass)
|
|||||||
return Data_Wrap_Struct(klass, 0, free, 0);
|
return Data_Wrap_Struct(klass, 0, free, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* XXX: An uninitialized buffer may lead ALGO_Equal() to fail */
|
pctx = xmalloc(algo->ctx_size);
|
||||||
pctx = xcalloc(algo->ctx_size, 1);
|
|
||||||
algo->init_func(pctx);
|
algo->init_func(pctx);
|
||||||
|
|
||||||
obj = Data_Wrap_Struct(klass, 0, free, pctx);
|
obj = Data_Wrap_Struct(klass, 0, free, pctx);
|
||||||
@ -208,7 +207,7 @@ rb_digest_base_copy(VALUE copy, VALUE obj)
|
|||||||
algo = get_digest_base_metadata(rb_obj_class(copy));
|
algo = get_digest_base_metadata(rb_obj_class(copy));
|
||||||
|
|
||||||
if (algo == NULL) {
|
if (algo == NULL) {
|
||||||
/* subclasses must define initialize_copy() */
|
/* initialize_copy() is undefined or something */
|
||||||
rb_notimplement();
|
rb_notimplement();
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -375,25 +374,22 @@ rb_digest_base_equal(VALUE self, VALUE other)
|
|||||||
VALUE str1, str2;
|
VALUE str1, str2;
|
||||||
|
|
||||||
klass = rb_obj_class(self);
|
klass = rb_obj_class(self);
|
||||||
algo = get_digest_base_metadata(klass);
|
|
||||||
|
|
||||||
if (rb_obj_class(other) == klass) {
|
if (rb_obj_class(other) == klass) {
|
||||||
void *pctx1, *pctx2;
|
str1 = rb_digest_base_digest(self);
|
||||||
|
str2 = rb_digest_base_digest(other);
|
||||||
|
} else {
|
||||||
|
StringValue(other);
|
||||||
|
str2 = other;
|
||||||
|
|
||||||
Data_Get_Struct(self, void, pctx1);
|
algo = get_digest_base_metadata(klass);
|
||||||
Data_Get_Struct(other, void, pctx2);
|
|
||||||
|
|
||||||
return algo->equal_func(pctx1, pctx2) ? Qtrue : Qfalse;
|
if (RSTRING_LEN(str2) == algo->digest_len)
|
||||||
|
str1 = rb_digest_base_digest(self);
|
||||||
|
else
|
||||||
|
str1 = rb_digest_base_hexdigest(self);
|
||||||
}
|
}
|
||||||
|
|
||||||
StringValue(other);
|
|
||||||
str2 = other;
|
|
||||||
|
|
||||||
if (RSTRING_LEN(str2) == algo->digest_len)
|
|
||||||
str1 = rb_digest_base_digest(self);
|
|
||||||
else
|
|
||||||
str1 = rb_digest_base_hexdigest(self);
|
|
||||||
|
|
||||||
if (RSTRING_LEN(str1) == RSTRING_LEN(str2)
|
if (RSTRING_LEN(str1) == RSTRING_LEN(str2)
|
||||||
&& rb_str_cmp(str1, str2) == 0)
|
&& rb_str_cmp(str1, str2) == 0)
|
||||||
return Qtrue;
|
return Qtrue;
|
||||||
|
@ -18,7 +18,6 @@
|
|||||||
typedef void (*hash_init_func_t)(void *);
|
typedef void (*hash_init_func_t)(void *);
|
||||||
typedef void (*hash_update_func_t)(void *, unsigned char *, size_t);
|
typedef void (*hash_update_func_t)(void *, unsigned char *, size_t);
|
||||||
typedef void (*hash_finish_func_t)(void *, unsigned char *);
|
typedef void (*hash_finish_func_t)(void *, unsigned char *);
|
||||||
typedef int (*hash_equal_func_t)(void *, void *);
|
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
size_t digest_len;
|
size_t digest_len;
|
||||||
@ -26,5 +25,4 @@ typedef struct {
|
|||||||
hash_init_func_t init_func;
|
hash_init_func_t init_func;
|
||||||
hash_update_func_t update_func;
|
hash_update_func_t update_func;
|
||||||
hash_finish_func_t finish_func;
|
hash_finish_func_t finish_func;
|
||||||
hash_equal_func_t equal_func;
|
|
||||||
} algo_t;
|
} algo_t;
|
||||||
|
@ -418,9 +418,3 @@ MD5_Finish(MD5_CTX *pms, uint8_t *digest)
|
|||||||
for (i = 0; i < 16; ++i)
|
for (i = 0; i < 16; ++i)
|
||||||
digest[i] = (uint8_t)(pms->state[i >> 2] >> ((i & 3) << 3));
|
digest[i] = (uint8_t)(pms->state[i >> 2] >> ((i & 3) << 3));
|
||||||
}
|
}
|
||||||
|
|
||||||
int MD5_Equal(MD5_CTX* pctx1, MD5_CTX* pctx2) {
|
|
||||||
return memcmp(pctx1->count, pctx2->count, sizeof(pctx1->count)) == 0
|
|
||||||
&& memcmp(pctx1->state, pctx2->state, sizeof(pctx1->state)) == 0
|
|
||||||
&& memcmp(pctx1->buffer, pctx2->buffer, sizeof(pctx1->buffer)) == 0;
|
|
||||||
}
|
|
||||||
|
@ -67,13 +67,11 @@ typedef struct md5_state_s {
|
|||||||
#define MD5_Init rb_Digest_MD5_Init
|
#define MD5_Init rb_Digest_MD5_Init
|
||||||
#define MD5_Update rb_Digest_MD5_Update
|
#define MD5_Update rb_Digest_MD5_Update
|
||||||
#define MD5_Finish rb_Digest_MD5_Finish
|
#define MD5_Finish rb_Digest_MD5_Finish
|
||||||
#define MD5_Equal rb_Digest_MD5_Equal
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
void MD5_Init _((MD5_CTX *pms));
|
void MD5_Init _((MD5_CTX *pms));
|
||||||
void MD5_Update _((MD5_CTX *pms, const uint8_t *data, size_t nbytes));
|
void MD5_Update _((MD5_CTX *pms, const uint8_t *data, size_t nbytes));
|
||||||
void MD5_Finish _((MD5_CTX *pms, uint8_t *digest));
|
void MD5_Finish _((MD5_CTX *pms, uint8_t *digest));
|
||||||
int MD5_Equal _((MD5_CTX *pctx1, MD5_CTX *pctx2));
|
|
||||||
|
|
||||||
#define MD5_BLOCK_LENGTH 64
|
#define MD5_BLOCK_LENGTH 64
|
||||||
#define MD5_DIGEST_LENGTH 16
|
#define MD5_DIGEST_LENGTH 16
|
||||||
|
@ -14,7 +14,6 @@ static algo_t md5 = {
|
|||||||
(hash_init_func_t)MD5_Init,
|
(hash_init_func_t)MD5_Init,
|
||||||
(hash_update_func_t)MD5_Update,
|
(hash_update_func_t)MD5_Update,
|
||||||
(hash_finish_func_t)MD5_Finish,
|
(hash_finish_func_t)MD5_Finish,
|
||||||
(hash_equal_func_t)MD5_Equal,
|
|
||||||
};
|
};
|
||||||
|
|
||||||
void
|
void
|
||||||
|
@ -1,24 +1,9 @@
|
|||||||
/* $Id$ */
|
/* $Id$ */
|
||||||
|
|
||||||
#include "md5ossl.h"
|
#include "md5ossl.h"
|
||||||
#include <sys/types.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
void
|
void
|
||||||
MD5_Finish(MD5_CTX *pctx, unsigned char *digest)
|
MD5_Finish(MD5_CTX *pctx, unsigned char *digest)
|
||||||
{
|
{
|
||||||
MD5_Final(digest, pctx);
|
MD5_Final(digest, pctx);
|
||||||
}
|
}
|
||||||
|
|
||||||
int
|
|
||||||
MD5_Equal(MD5_CTX* pctx1, MD5_CTX* pctx2) {
|
|
||||||
return pctx1->num == pctx2->num
|
|
||||||
&& pctx1->A == pctx2->A
|
|
||||||
&& pctx1->B == pctx2->B
|
|
||||||
&& pctx1->C == pctx2->C
|
|
||||||
&& pctx1->D == pctx2->D
|
|
||||||
&& pctx1->Nl == pctx2->Nl
|
|
||||||
&& pctx1->Nh == pctx2->Nh
|
|
||||||
&& memcmp(pctx1->data, pctx2->data, sizeof(pctx1->data)) == 0;
|
|
||||||
}
|
|
||||||
|
@ -9,6 +9,5 @@
|
|||||||
#define MD5_BLOCK_LENGTH MD5_CBLOCK
|
#define MD5_BLOCK_LENGTH MD5_CBLOCK
|
||||||
|
|
||||||
void MD5_Finish(MD5_CTX *pctx, unsigned char *digest);
|
void MD5_Finish(MD5_CTX *pctx, unsigned char *digest);
|
||||||
int MD5_Equal(MD5_CTX *pctx1, MD5_CTX *pctx2);
|
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
@ -454,11 +454,4 @@ RMD160_Finish(RMD160_CTX *context, uint8_t digest[20])
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
int RMD160_Equal(RMD160_CTX* pctx1, RMD160_CTX* pctx2) {
|
|
||||||
return pctx1->buflen == pctx2->buflen
|
|
||||||
&& memcmp(pctx1->length, pctx2->length, sizeof(pctx1->length)) == 0
|
|
||||||
&& memcmp(pctx1->state, pctx2->state, sizeof(pctx1->state)) == 0
|
|
||||||
&& memcmp(pctx1->bbuffer, pctx2->bbuffer, sizeof(pctx1->bbuffer)) == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/************************ end of file rmd160.c **********************/
|
/************************ end of file rmd160.c **********************/
|
||||||
|
@ -40,7 +40,6 @@ typedef struct {
|
|||||||
#define RMD160_Transform rb_Digest_RMD160_Transform
|
#define RMD160_Transform rb_Digest_RMD160_Transform
|
||||||
#define RMD160_Update rb_Digest_RMD160_Update
|
#define RMD160_Update rb_Digest_RMD160_Update
|
||||||
#define RMD160_Finish rb_Digest_RMD160_Finish
|
#define RMD160_Finish rb_Digest_RMD160_Finish
|
||||||
#define RMD160_Equal rb_Digest_RMD160_Equal
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
__BEGIN_DECLS
|
__BEGIN_DECLS
|
||||||
@ -48,7 +47,6 @@ void RMD160_Init _((RMD160_CTX *));
|
|||||||
void RMD160_Transform _((uint32_t[5], const uint32_t[16]));
|
void RMD160_Transform _((uint32_t[5], const uint32_t[16]));
|
||||||
void RMD160_Update _((RMD160_CTX *, const uint8_t *, size_t));
|
void RMD160_Update _((RMD160_CTX *, const uint8_t *, size_t));
|
||||||
void RMD160_Finish _((RMD160_CTX *, uint8_t[20]));
|
void RMD160_Finish _((RMD160_CTX *, uint8_t[20]));
|
||||||
int RMD160_Equal _((RMD160_CTX *, RMD160_CTX *));
|
|
||||||
__END_DECLS
|
__END_DECLS
|
||||||
|
|
||||||
#define RMD160_BLOCK_LENGTH 64
|
#define RMD160_BLOCK_LENGTH 64
|
||||||
|
@ -14,7 +14,6 @@ static algo_t rmd160 = {
|
|||||||
(hash_init_func_t)RMD160_Init,
|
(hash_init_func_t)RMD160_Init,
|
||||||
(hash_update_func_t)RMD160_Update,
|
(hash_update_func_t)RMD160_Update,
|
||||||
(hash_finish_func_t)RMD160_Finish,
|
(hash_finish_func_t)RMD160_Finish,
|
||||||
(hash_equal_func_t)RMD160_Equal,
|
|
||||||
};
|
};
|
||||||
|
|
||||||
void
|
void
|
||||||
|
@ -2,21 +2,7 @@
|
|||||||
|
|
||||||
#include "defs.h"
|
#include "defs.h"
|
||||||
#include "rmd160ossl.h"
|
#include "rmd160ossl.h"
|
||||||
#include <assert.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
|
|
||||||
void RMD160_Finish(RMD160_CTX *ctx, char *buf) {
|
void RMD160_Finish(RMD160_CTX *ctx, char *buf) {
|
||||||
RIPEMD160_Final(buf, ctx);
|
RIPEMD160_Final(buf, ctx);
|
||||||
}
|
}
|
||||||
|
|
||||||
int RMD160_Equal(RMD160_CTX* pctx1, RMD160_CTX* pctx2) {
|
|
||||||
return pctx1->num == pctx2->num
|
|
||||||
&& pctx1->A == pctx2->A
|
|
||||||
&& pctx1->B == pctx2->B
|
|
||||||
&& pctx1->C == pctx2->C
|
|
||||||
&& pctx1->D == pctx2->D
|
|
||||||
&& pctx1->E == pctx2->E
|
|
||||||
&& pctx1->Nl == pctx2->Nl
|
|
||||||
&& pctx1->Nh == pctx2->Nh
|
|
||||||
&& memcmp(pctx1->data, pctx2->data, sizeof(pctx1->data)) == 0;
|
|
||||||
}
|
|
||||||
|
@ -15,6 +15,5 @@
|
|||||||
#define RMD160_DIGEST_LENGTH RIPEMD160_DIGEST_LENGTH
|
#define RMD160_DIGEST_LENGTH RIPEMD160_DIGEST_LENGTH
|
||||||
|
|
||||||
void RMD160_Finish(RMD160_CTX *ctx, char *buf);
|
void RMD160_Finish(RMD160_CTX *ctx, char *buf);
|
||||||
int RMD160_Equal(RMD160_CTX *pctx1, RMD160_CTX *pctx2);
|
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
@ -267,9 +267,3 @@ void SHA1_Finish(SHA1_CTX* context, uint8_t digest[20])
|
|||||||
((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
|
((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
int SHA1_Equal(SHA1_CTX* pctx1, SHA1_CTX* pctx2) {
|
|
||||||
return memcmp(pctx1->count, pctx2->count, sizeof(pctx1->count)) == 0
|
|
||||||
&& memcmp(pctx1->state, pctx2->state, sizeof(pctx1->state)) == 0
|
|
||||||
&& memcmp(pctx1->buffer, pctx2->buffer, sizeof(pctx1->buffer)) == 0;
|
|
||||||
}
|
|
||||||
|
@ -25,14 +25,12 @@ typedef struct {
|
|||||||
#define SHA1_Init rb_Digest_SHA1_Init
|
#define SHA1_Init rb_Digest_SHA1_Init
|
||||||
#define SHA1_Update rb_Digest_SHA1_Update
|
#define SHA1_Update rb_Digest_SHA1_Update
|
||||||
#define SHA1_Finish rb_Digest_SHA1_Finish
|
#define SHA1_Finish rb_Digest_SHA1_Finish
|
||||||
#define SHA1_Equal rb_Digest_SHA1_Equal
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
void SHA1_Transform _((uint32_t state[5], const uint8_t buffer[64]));
|
void SHA1_Transform _((uint32_t state[5], const uint8_t buffer[64]));
|
||||||
void SHA1_Init _((SHA1_CTX *context));
|
void SHA1_Init _((SHA1_CTX *context));
|
||||||
void SHA1_Update _((SHA1_CTX *context, const uint8_t *data, size_t len));
|
void SHA1_Update _((SHA1_CTX *context, const uint8_t *data, size_t len));
|
||||||
void SHA1_Finish _((SHA1_CTX *context, uint8_t digest[20]));
|
void SHA1_Finish _((SHA1_CTX *context, uint8_t digest[20]));
|
||||||
int SHA1_Equal _((SHA1_CTX *pctx1, SHA1_CTX *pctx2));
|
|
||||||
|
|
||||||
#define SHA1_BLOCK_LENGTH 64
|
#define SHA1_BLOCK_LENGTH 64
|
||||||
#define SHA1_DIGEST_LENGTH 20
|
#define SHA1_DIGEST_LENGTH 20
|
||||||
|
@ -14,7 +14,6 @@ static algo_t sha1 = {
|
|||||||
(hash_init_func_t)SHA1_Init,
|
(hash_init_func_t)SHA1_Init,
|
||||||
(hash_update_func_t)SHA1_Update,
|
(hash_update_func_t)SHA1_Update,
|
||||||
(hash_finish_func_t)SHA1_Finish,
|
(hash_finish_func_t)SHA1_Finish,
|
||||||
(hash_equal_func_t)SHA1_Equal,
|
|
||||||
};
|
};
|
||||||
|
|
||||||
void
|
void
|
||||||
|
@ -2,24 +2,9 @@
|
|||||||
|
|
||||||
#include "defs.h"
|
#include "defs.h"
|
||||||
#include "sha1ossl.h"
|
#include "sha1ossl.h"
|
||||||
#include <stdlib.h>
|
|
||||||
|
|
||||||
void
|
void
|
||||||
SHA1_Finish(SHA1_CTX *ctx, char *buf)
|
SHA1_Finish(SHA1_CTX *ctx, char *buf)
|
||||||
{
|
{
|
||||||
SHA1_Final(buf, ctx);
|
SHA1_Final(buf, ctx);
|
||||||
}
|
}
|
||||||
|
|
||||||
int
|
|
||||||
SHA1_Equal(SHA1_CTX* pctx1, SHA1_CTX* pctx2)
|
|
||||||
{
|
|
||||||
return pctx1->num == pctx2->num
|
|
||||||
&& pctx1->h0 == pctx2->h0
|
|
||||||
&& pctx1->h1 == pctx2->h1
|
|
||||||
&& pctx1->h2 == pctx2->h2
|
|
||||||
&& pctx1->h3 == pctx2->h3
|
|
||||||
&& pctx1->h4 == pctx2->h4
|
|
||||||
&& pctx1->Nl == pctx2->Nl
|
|
||||||
&& pctx1->Nh == pctx2->Nh
|
|
||||||
&& memcmp(pctx1->data, pctx2->data, sizeof(pctx1->data)) == 0;
|
|
||||||
}
|
|
||||||
|
@ -16,6 +16,5 @@
|
|||||||
#define SHA1_DIGEST_LENGTH SHA_DIGEST_LENGTH
|
#define SHA1_DIGEST_LENGTH SHA_DIGEST_LENGTH
|
||||||
|
|
||||||
void SHA1_Finish(SHA1_CTX *ctx, char *buf);
|
void SHA1_Finish(SHA1_CTX *ctx, char *buf);
|
||||||
int SHA1_Equal(SHA1_CTX *pctx1, SHA1_CTX *pctx2);
|
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
@ -578,12 +578,6 @@ void SHA256_Finish(SHA256_CTX* context, sha2_byte digest[]) {
|
|||||||
usedspace = 0;
|
usedspace = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int SHA256_Equal(SHA256_CTX* pctx1, SHA256_CTX* pctx2) {
|
|
||||||
return pctx1->bitcount == pctx2->bitcount
|
|
||||||
&& memcmp(pctx1->state, pctx2->state, sizeof(pctx1->state)) == 0
|
|
||||||
&& memcmp(pctx1->buffer, pctx2->buffer, sizeof(pctx1->buffer)) == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*** SHA-512: *********************************************************/
|
/*** SHA-512: *********************************************************/
|
||||||
void SHA512_Init(SHA512_CTX* context) {
|
void SHA512_Init(SHA512_CTX* context) {
|
||||||
if (context == (SHA512_CTX*)0) {
|
if (context == (SHA512_CTX*)0) {
|
||||||
@ -881,12 +875,6 @@ void SHA512_Finish(SHA512_CTX* context, sha2_byte digest[]) {
|
|||||||
MEMSET_BZERO(context, sizeof(SHA512_CTX));
|
MEMSET_BZERO(context, sizeof(SHA512_CTX));
|
||||||
}
|
}
|
||||||
|
|
||||||
int SHA512_Equal(SHA512_CTX* pctx1, SHA512_CTX* pctx2) {
|
|
||||||
return memcmp(pctx1->bitcount, pctx2->bitcount, sizeof(pctx1->bitcount)) == 0
|
|
||||||
&& memcmp(pctx1->state, pctx2->state, sizeof(pctx1->state)) == 0
|
|
||||||
&& memcmp(pctx1->buffer, pctx2->buffer, sizeof(pctx1->buffer)) == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*** SHA-384: *********************************************************/
|
/*** SHA-384: *********************************************************/
|
||||||
void SHA384_Init(SHA384_CTX* context) {
|
void SHA384_Init(SHA384_CTX* context) {
|
||||||
if (context == (SHA384_CTX*)0) {
|
if (context == (SHA384_CTX*)0) {
|
||||||
@ -929,9 +917,3 @@ void SHA384_Finish(SHA384_CTX* context, sha2_byte digest[]) {
|
|||||||
/* Zero out state data */
|
/* Zero out state data */
|
||||||
MEMSET_BZERO(context, sizeof(SHA384_CTX));
|
MEMSET_BZERO(context, sizeof(SHA384_CTX));
|
||||||
}
|
}
|
||||||
|
|
||||||
int SHA384_Equal(SHA384_CTX* pctx1, SHA384_CTX* pctx2) {
|
|
||||||
return memcmp(pctx1->bitcount, pctx2->bitcount, sizeof(pctx1->bitcount)) == 0
|
|
||||||
&& memcmp(pctx1->state, pctx2->state, sizeof(pctx1->state)) == 0
|
|
||||||
&& memcmp(pctx1->buffer, pctx2->buffer, sizeof(pctx1->buffer)) == 0;
|
|
||||||
}
|
|
||||||
|
@ -78,34 +78,28 @@ typedef SHA512_CTX SHA384_CTX;
|
|||||||
#define SHA256_Init rb_Digest_SHA256_Init
|
#define SHA256_Init rb_Digest_SHA256_Init
|
||||||
#define SHA256_Update rb_Digest_SHA256_Update
|
#define SHA256_Update rb_Digest_SHA256_Update
|
||||||
#define SHA256_Finish rb_Digest_SHA256_Finish
|
#define SHA256_Finish rb_Digest_SHA256_Finish
|
||||||
#define SHA256_Equal rb_Digest_SHA256_Equal
|
|
||||||
|
|
||||||
#define SHA384_Init rb_Digest_SHA384_Init
|
#define SHA384_Init rb_Digest_SHA384_Init
|
||||||
#define SHA384_Update rb_Digest_SHA384_Update
|
#define SHA384_Update rb_Digest_SHA384_Update
|
||||||
#define SHA384_Finish rb_Digest_SHA384_Finish
|
#define SHA384_Finish rb_Digest_SHA384_Finish
|
||||||
#define SHA384_Equal rb_Digest_SHA384_Equal
|
|
||||||
|
|
||||||
#define SHA512_Init rb_Digest_SHA512_Init
|
#define SHA512_Init rb_Digest_SHA512_Init
|
||||||
#define SHA512_Update rb_Digest_SHA512_Update
|
#define SHA512_Update rb_Digest_SHA512_Update
|
||||||
#define SHA512_Finish rb_Digest_SHA512_Finish
|
#define SHA512_Finish rb_Digest_SHA512_Finish
|
||||||
#define SHA512_Equal rb_Digest_SHA512_Equal
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/*** SHA-256/384/512 Function Prototypes ******************************/
|
/*** SHA-256/384/512 Function Prototypes ******************************/
|
||||||
void SHA256_Init _((SHA256_CTX *));
|
void SHA256_Init _((SHA256_CTX *));
|
||||||
void SHA256_Update _((SHA256_CTX*, const uint8_t*, size_t));
|
void SHA256_Update _((SHA256_CTX*, const uint8_t*, size_t));
|
||||||
void SHA256_Finish _((SHA256_CTX*, uint8_t[SHA256_DIGEST_LENGTH]));
|
void SHA256_Finish _((SHA256_CTX*, uint8_t[SHA256_DIGEST_LENGTH]));
|
||||||
int SHA256_Equal _((SHA256_CTX*, SHA256_CTX*));
|
|
||||||
|
|
||||||
void SHA384_Init _((SHA384_CTX*));
|
void SHA384_Init _((SHA384_CTX*));
|
||||||
void SHA384_Update _((SHA384_CTX*, const uint8_t*, size_t));
|
void SHA384_Update _((SHA384_CTX*, const uint8_t*, size_t));
|
||||||
void SHA384_Finish _((SHA384_CTX*, uint8_t[SHA384_DIGEST_LENGTH]));
|
void SHA384_Finish _((SHA384_CTX*, uint8_t[SHA384_DIGEST_LENGTH]));
|
||||||
int SHA384_Equal _((SHA384_CTX*, SHA384_CTX*));
|
|
||||||
|
|
||||||
void SHA512_Init _((SHA512_CTX*));
|
void SHA512_Init _((SHA512_CTX*));
|
||||||
void SHA512_Update _((SHA512_CTX*, const uint8_t*, size_t));
|
void SHA512_Update _((SHA512_CTX*, const uint8_t*, size_t));
|
||||||
void SHA512_Finish _((SHA512_CTX*, uint8_t[SHA512_DIGEST_LENGTH]));
|
void SHA512_Finish _((SHA512_CTX*, uint8_t[SHA512_DIGEST_LENGTH]));
|
||||||
int SHA512_Equal _((SHA512_CTX*, SHA512_CTX*));
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
}
|
}
|
||||||
|
@ -13,7 +13,6 @@ static algo_t sha##bitlen = { \
|
|||||||
(hash_init_func_t)SHA##bitlen##_Init, \
|
(hash_init_func_t)SHA##bitlen##_Init, \
|
||||||
(hash_update_func_t)SHA##bitlen##_Update, \
|
(hash_update_func_t)SHA##bitlen##_Update, \
|
||||||
(hash_finish_func_t)SHA##bitlen##_Finish, \
|
(hash_finish_func_t)SHA##bitlen##_Finish, \
|
||||||
(hash_equal_func_t)SHA##bitlen##_Equal, \
|
|
||||||
};
|
};
|
||||||
|
|
||||||
FOREACH_BITLEN(DEFINE_ALGO_METADATA)
|
FOREACH_BITLEN(DEFINE_ALGO_METADATA)
|
||||||
|
Loading…
x
Reference in New Issue
Block a user