0,0 → 1,316 |
/* Copyright © 2007 Carl Worth |
* Copyright © 2009 Jeremy Huddleston, Julien Cristau, and Matthieu Herrb |
* Copyright © 2009-2010 Mikhail Gusarov |
* Copyright © 2012 Yaakov Selkowitz and Keith Packard |
* Copyright © 2014 Intel Corporation |
* |
* Permission is hereby granted, free of charge, to any person obtaining a |
* copy of this software and associated documentation files (the "Software"), |
* to deal in the Software without restriction, including without limitation |
* the rights to use, copy, modify, merge, publish, distribute, sublicense, |
* and/or sell copies of the Software, and to permit persons to whom the |
* Software is furnished to do so, subject to the following conditions: |
* |
* The above copyright notice and this permission notice (including the next |
* paragraph) shall be included in all copies or substantial portions of the |
* Software. |
* |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
* DEALINGS IN THE SOFTWARE. |
*/ |
|
#include "mesa-sha1.h" |
|
#if defined(HAVE_SHA1_IN_LIBMD) /* Use libmd for SHA1 */ \ |
|| defined(HAVE_SHA1_IN_LIBC) /* Use libc for SHA1 */ |
|
#include <sha1.h> |
|
struct mesa_sha1 * |
_mesa_sha1_init(void) |
{ |
SHA1_CTX *ctx = malloc(sizeof(*ctx)); |
|
if (!ctx) |
return NULL; |
|
SHA1Init(ctx); |
return (struct mesa_sha1 *) ctx; |
} |
|
int |
_mesa_sha1_update(struct mesa_sha1 *ctx, const void *data, int size) |
{ |
SHA1_CTX *sha1_ctx = (SHA1_CTX *) ctx; |
|
SHA1Update(sha1_ctx, data, size); |
return 1; |
} |
|
int |
_mesa_sha1_final(struct mesa_sha1 *ctx, unsigned char result[20]) |
{ |
SHA1_CTX *sha1_ctx = (SHA1_CTX *) ctx; |
|
SHA1Final(result, sha1_ctx); |
free(sha1_ctx); |
return 1; |
} |
|
#elif defined(HAVE_SHA1_IN_COMMONCRYPTO) /* Use CommonCrypto for SHA1 */ |
|
#include <CommonCrypto/CommonDigest.h> |
|
struct mesa_sha1 * |
_mesa_sha1_init(void) |
{ |
CC_SHA1_CTX *ctx = malloc(sizeof(*ctx)); |
|
if (!ctx) |
return NULL; |
|
CC_SHA1_Init(ctx); |
return (struct mesa_sha1 *) ctx; |
} |
|
int |
_mesa_sha1_update(struct mesa_sha1 *ctx, const void *data, int size) |
{ |
CC_SHA1_CTX *sha1_ctx = (CC_SHA1_CTX *) ctx; |
|
CC_SHA1_Update(sha1_ctx, data, size); |
return 1; |
} |
|
int |
_mesa_sha1_final(struct mesa_sha1 *ctx, unsigned char result[20]) |
{ |
CC_SHA1_CTX *sha1_ctx = (CC_SHA1_CTX *) ctx; |
|
CC_SHA1_Final(result, sha1_ctx); |
free(sha1_ctx); |
return 1; |
} |
|
#elif defined(HAVE_SHA1_IN_CRYPTOAPI) /* Use CryptoAPI for SHA1 */ |
|
#define WIN32_LEAN_AND_MEAN |
#include <windows.h> |
#include <wincrypt.h> |
|
static HCRYPTPROV hProv; |
|
struct mesa_sha1 * |
_mesa_sha1_init(void) |
{ |
HCRYPTHASH *ctx = malloc(sizeof(*ctx)); |
|
if (!ctx) |
return NULL; |
|
CryptAcquireContext(&hProv, NULL, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT); |
CryptCreateHash(hProv, CALG_SHA1, 0, 0, ctx); |
return (struct mesa_sha1 *) ctx; |
} |
|
int |
_mesa_sha1_update(struct mesa_sha1 *ctx, const void *data, int size) |
{ |
HCRYPTHASH *hHash = (HCRYPTHASH *) ctx; |
|
CryptHashData(*hHash, data, size, 0); |
return 1; |
} |
|
int |
_mesa_sha1_final(struct mesa_sha1 *ctx, unsigned char result[20]) |
{ |
HCRYPTHASH *hHash = (HCRYPTHASH *) ctx; |
DWORD len = 20; |
|
CryptGetHashParam(*hHash, HP_HASHVAL, result, &len, 0); |
CryptDestroyHash(*hHash); |
CryptReleaseContext(hProv, 0); |
free(ctx); |
return 1; |
} |
|
#elif defined(HAVE_SHA1_IN_LIBNETTLE) /* Use libnettle for SHA1 */ |
|
#include <nettle/sha.h> |
|
struct mesa_sha1 * |
_mesa_sha1_init(void) |
{ |
struct sha1_ctx *ctx = malloc(sizeof(*ctx)); |
|
if (!ctx) |
return NULL; |
sha1_init(ctx); |
return (struct mesa_sha1 *) ctx; |
} |
|
int |
_mesa_sha1_update(struct mesa_sha1 *ctx, const void *data, int size) |
{ |
sha1_update((struct sha1_ctx *) ctx, size, data); |
return 1; |
} |
|
int |
_mesa_sha1_final(struct mesa_sha1 *ctx, unsigned char result[20]) |
{ |
sha1_digest((struct sha1_ctx *) ctx, 20, result); |
free(ctx); |
return 1; |
} |
|
#elif defined(HAVE_SHA1_IN_LIBGCRYPT) /* Use libgcrypt for SHA1 */ |
|
#include <gcrypt.h> |
|
struct mesa_sha1 * |
_mesa_sha1_init(void) |
{ |
static int init; |
gcry_md_hd_t h; |
gcry_error_t err; |
|
if (!init) { |
if (!gcry_check_version(NULL)) |
return NULL; |
gcry_control(GCRYCTL_DISABLE_SECMEM, 0); |
gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0); |
init = 1; |
} |
|
err = gcry_md_open(&h, GCRY_MD_SHA1, 0); |
if (err) |
return NULL; |
return (struct mesa_sha1 *) h; |
} |
|
int |
_mesa_sha1_update(struct mesa_sha1 *ctx, const void *data, int size) |
{ |
gcry_md_hd_t h = (gcry_md_hd_t) ctx; |
|
gcry_md_write(h, data, size); |
return 1; |
} |
|
int |
_mesa_sha1_final(struct mesa_sha1 *ctx, unsigned char result[20]) |
{ |
gcry_md_hd_t h = (gcry_md_hd_t) ctx; |
|
memcpy(result, gcry_md_read(h, GCRY_MD_SHA1), 20); |
gcry_md_close(h); |
return 1; |
} |
|
#elif defined(HAVE_SHA1_IN_LIBSHA1) /* Use libsha1 */ |
|
#include <libsha1.h> |
|
struct mesa_sha1 * |
_mesa_sha1_init(void) |
{ |
sha1_ctx *ctx = malloc(sizeof(*ctx)); |
|
if (!ctx) |
return NULL; |
sha1_begin(ctx); |
return (struct mesa_sha1 *) ctx; |
} |
|
int |
_mesa_sha1_update(struct mesa_sha1 *ctx, const void *data, int size) |
{ |
sha1_hash(data, size, (sha1_ctx *) ctx); |
return 1; |
} |
|
int |
_mesa_sha1_final(struct mesa_sha1 *ctx, unsigned char result[20]) |
{ |
sha1_end(result, (sha1_ctx *) ctx); |
free(ctx); |
return 1; |
} |
|
#else /* Use OpenSSL's libcrypto */ |
|
#include <stddef.h> /* buggy openssl/sha.h wants size_t */ |
#include <openssl/sha.h> |
|
struct mesa_sha1 * |
_mesa_sha1_init(void) |
{ |
int ret; |
SHA_CTX *ctx = malloc(sizeof(*ctx)); |
|
if (!ctx) |
return NULL; |
ret = SHA1_Init(ctx); |
if (!ret) { |
free(ctx); |
return NULL; |
} |
return (struct mesa_sha1 *) ctx; |
} |
|
int |
_mesa_sha1_update(struct mesa_sha1 *ctx, const void *data, int size) |
{ |
int ret; |
SHA_CTX *sha_ctx = (SHA_CTX *) ctx; |
|
ret = SHA1_Update(sha_ctx, data, size); |
if (!ret) |
free(sha_ctx); |
return ret; |
} |
|
int |
_mesa_sha1_final(struct mesa_sha1 *ctx, unsigned char result[20]) |
{ |
int ret; |
SHA_CTX *sha_ctx = (SHA_CTX *) ctx; |
|
ret = SHA1_Final(result, (SHA_CTX *) sha_ctx); |
free(sha_ctx); |
return ret; |
} |
|
#endif |
|
void |
_mesa_sha1_compute(const void *data, size_t size, unsigned char result[20]) |
{ |
struct mesa_sha1 *ctx; |
|
ctx = _mesa_sha1_init(); |
_mesa_sha1_update(ctx, data, size); |
_mesa_sha1_final(ctx, result); |
} |
|
char * |
_mesa_sha1_format(char *buf, const unsigned char *sha1) |
{ |
static const char hex_digits[] = "0123456789abcdef"; |
int i; |
|
for (i = 0; i < 40; i += 2) { |
buf[i] = hex_digits[sha1[i >> 1] >> 4]; |
buf[i + 1] = hex_digits[sha1[i >> 1] & 0x0f]; |
} |
buf[i] = '\0'; |
|
return buf; |
} |