#include <corecrypto/cc.h>
#include <corecrypto/ccn.h>
-#ifdef USE_SUPER_COOL_NEW_CCOID_T
-#include <corecrypto/ccasn1.h>
-#endif /* USE_SUPER_COOL_NEW_CCOID_T */
-
+
/* To malloc a digest context for a given di, use malloc(ccdigest_di_size(di))
and assign the result to a pointer to a struct ccdigest_ctx. */
+#if CORECRYPTO_USE_TRANSPARENT_UNION
struct ccdigest_ctx {
union {
uint8_t u8;
uint64_t u64;
cc_unit ccn;
} state;
-} __attribute((aligned(8)));
+} CC_ALIGNED(8);
typedef union {
struct ccdigest_ctx *hdr;
uint64_t u64;
cc_unit ccn;
} state;
-} __attribute((aligned(8)));
+} CC_ALIGNED(8);
typedef union {
struct ccdigest_state *hdr;
struct ccdigest_ctx *_ctx;
ccdigest_ctx_t _ctxt;
} ccdigest_state_t __attribute__((transparent_union));
+#else //=======================================================
+struct ccdigest_ctx {
+ union {
+ uint8_t u8;
+ uint32_t u32;
+ uint64_t u64;
+ cc_unit ccn;
+ } state;
+} CC_ALIGNED(8);
+
+typedef struct ccdigest_ctx *ccdigest_ctx_t ;
+
+struct ccdigest_state {
+ union {
+ uint8_t u8;
+ uint32_t u32;
+ uint64_t u64;
+ cc_unit ccn;
+ } state;
+} CC_ALIGNED(8);
+
+typedef struct ccdigest_state *ccdigest_state_t;
+#endif //=======================================================
+
struct ccdigest_info {
- unsigned long output_size;
- unsigned long state_size;
- unsigned long block_size;
- unsigned long oid_size;
-#ifdef USE_SUPER_COOL_NEW_CCOID_T
- ccoid_t oid;
-#else
- unsigned char *oid;
-#endif
+ size_t output_size;
+ size_t state_size;
+ size_t block_size;
+ size_t oid_size;
+ const unsigned char *oid;
const void *initial_state;
- void(*compress)(ccdigest_state_t state, unsigned long nblocks,
+ void(*compress)(ccdigest_state_t state, size_t nblocks,
const void *data);
void(*final)(const struct ccdigest_info *di, ccdigest_ctx_t ctx,
unsigned char *digest);
#define ccdigest_di_clear(_di_, _name_) cc_clear(ccdigest_di_size(_di_), _name_)
/* Digest context field accessors. Consider the implementation private. */
-
+#if CORECRYPTO_USE_TRANSPARENT_UNION
#define ccdigest_state(_di_, _ctx_) ((struct ccdigest_state *)(&((ccdigest_ctx_t)(_ctx_)).hdr->state.u8 + sizeof(uint64_t)))
+#else
+#define ccdigest_state(_di_, _ctx_) ((struct ccdigest_state *)(&((ccdigest_ctx_t)(_ctx_))->state.u8 + sizeof(uint64_t)))
+#endif
+
#define ccdigest_state_u8(_di_, _ctx_) ccdigest_u8(ccdigest_state((_di_), (_ctx_)))
#define ccdigest_state_u32(_di_, _ctx_) ccdigest_u32(ccdigest_state((_di_), (_ctx_)))
#define ccdigest_state_u64(_di_, _ctx_) ccdigest_u64(ccdigest_state((_di_), (_ctx_)))
#define ccdigest_state_ccn(_di_, _ctx_) ccdigest_ccn(ccdigest_state((_di_), (_ctx_)))
-#define ccdigest_nbits(_di_, _ctx_) (((uint64_t *)(&((ccdigest_ctx_t)(_ctx_)).hdr->state.u8))[0])
+#if CORECRYPTO_USE_TRANSPARENT_UNION
+#define ccdigest_nbits(_di_, _ctx_) (((uint64_t *)(&((ccdigest_ctx_t)(_ctx_)).hdr->state.u8))[0])
#define ccdigest_data(_di_, _ctx_) (&((ccdigest_ctx_t)(_ctx_)).hdr->state.u8 + (_di_)->state_size + sizeof(uint64_t))
#define ccdigest_num(_di_, _ctx_) (((unsigned int *)(&((ccdigest_ctx_t)(_ctx_)).hdr->state.u8 + (_di_)->state_size + sizeof(uint64_t) + (_di_)->block_size))[0])
+#else
+#define ccdigest_nbits(_di_, _ctx_) (((uint64_t *)(&((ccdigest_ctx_t)(_ctx_))->state.u8))[0])
+#define ccdigest_data(_di_, _ctx_) (&((ccdigest_ctx_t)(_ctx_))->state.u8 + (_di_)->state_size + sizeof(uint64_t))
+#define ccdigest_num(_di_, _ctx_) (((unsigned int *)(&((ccdigest_ctx_t)(_ctx_))->state.u8 + (_di_)->state_size + sizeof(uint64_t) + (_di_)->block_size))[0])
+#endif
+#if CORECRYPTO_USE_TRANSPARENT_UNION
/* Digest state field accessors. Consider the implementation private. */
#define ccdigest_u8(_state_) (&((ccdigest_state_t)(_state_)).hdr->state.u8)
#define ccdigest_u32(_state_) (&((ccdigest_state_t)(_state_)).hdr->state.u32)
#define ccdigest_u64(_state_) (&((ccdigest_state_t)(_state_)).hdr->state.u64)
#define ccdigest_ccn(_state_) (&((ccdigest_state_t)(_state_)).hdr->state.ccn)
+#else
+/* Digest state field accessors. Consider the implementation private. */
+#define ccdigest_u8(_state_) (&((ccdigest_state_t)(_state_))->state.u8)
+#define ccdigest_u32(_state_) (&((ccdigest_state_t)(_state_))->state.u32)
+#define ccdigest_u64(_state_) (&((ccdigest_state_t)(_state_))->state.u64)
+#define ccdigest_ccn(_state_) (&((ccdigest_state_t)(_state_))->state.ccn)
+#endif
/* We could just use memcpy instead of this special macro, but this allows us
to use the optimized ccn_set() assembly routine if we have one, which for
void ccdigest_init(const struct ccdigest_info *di, ccdigest_ctx_t ctx);
void ccdigest_update(const struct ccdigest_info *di, ccdigest_ctx_t ctx,
- unsigned long len, const void *data);
+ size_t len, const void *data);
CC_INLINE
void ccdigest_final(const struct ccdigest_info *di, ccdigest_ctx_t ctx, unsigned char *digest)
di->final(di,ctx,digest);
}
-void ccdigest(const struct ccdigest_info *di, unsigned long len,
+void ccdigest(const struct ccdigest_info *di, size_t len,
const void *data, void *digest);
/* test functions */
-int ccdigest_test(const struct ccdigest_info *di, unsigned long len,
+int ccdigest_test(const struct ccdigest_info *di, size_t len,
const void *data, const void *digest);
-int ccdigest_test_chunk(const struct ccdigest_info *di, unsigned long len,
- const void *data, const void *digest, unsigned long chunk);
+int ccdigest_test_chunk(const struct ccdigest_info *di, size_t len,
+ const void *data, const void *digest, size_t chunk);
struct ccdigest_vector {
- unsigned long len;
+ size_t len;
const void *message;
const void *digest;
};
int ccdigest_test_vector(const struct ccdigest_info *di, const struct ccdigest_vector *v);
-int ccdigest_test_chunk_vector(const struct ccdigest_info *di, const struct ccdigest_vector *v, unsigned long chunk);
+int ccdigest_test_chunk_vector(const struct ccdigest_info *di, const struct ccdigest_vector *v, size_t chunk);
-#ifdef USE_SUPER_COOL_NEW_CCOID_T
-#define OID_DEF(_VALUE_) {((const unsigned char *) _VALUE_)}
-#else
-#define OID_DEF(_VALUE_) _VALUE_
-#endif
+
+#define OID_DEF(_VALUE_) ((const unsigned char *)_VALUE_)
#define CC_DIGEST_OID_MD2 OID_DEF("\x06\x08\x2A\x86\x48\x86\xF7\x0D\x02\x02")
#define CC_DIGEST_OID_MD4 OID_DEF("\x06\x08\x2A\x86\x48\x86\xF7\x0D\x02\x04")
#define CC_DIGEST_OID_RMD256 OID_DEF("\x06\x05\x2B\x24\x03\x02\x03")
#define CC_DIGEST_OID_RMD320 OID_DEF(NULL)
-
-#ifdef USE_SUPER_COOL_NEW_CCOID_T
-CC_INLINE CC_NONNULL_TU((1)) CC_NONNULL_TU((2))
-bool ccdigest_oid_equal(const struct ccdigest_info *di, ccoid_t oid) {
- if(di->oid.oid == NULL && oid.oid == NULL) return true;
- return ccoid_equal(di->oid, oid);
-}
-
-typedef const struct ccdigest_info *(ccdigest_lookup)(ccoid_t oid);
-
-#include <stdarg.h>
-const struct ccdigest_info *ccdigest_oid_lookup(ccoid_t oid, ...);
-#endif /* USE_SUPER_COOL_NEW_CCOID_T*/
#endif /* _CORECRYPTO_CCDIGEST_H_ */
projects / apple / xnu.git / blobdiff