mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-01-31 11:37:35 +00:00
0d3c1c8b1a
This change fixes stderr to be unbuffered. Added hardware AES on ARM64 to help safeguard against timing attacks. The curl.com command will be somewhat more pleasant to use.
575 lines
21 KiB
C
575 lines
21 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:4;coding:utf-8 -*-│
|
|
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
|
|
╞══════════════════════════════════════════════════════════════════════════════╡
|
|
│ Copyright The Mbed TLS Contributors │
|
|
│ │
|
|
│ Licensed under the Apache License, Version 2.0 (the "License"); │
|
|
│ you may not use this file except in compliance with the License. │
|
|
│ You may obtain a copy of the License at │
|
|
│ │
|
|
│ http://www.apache.org/licenses/LICENSE-2.0 │
|
|
│ │
|
|
│ Unless required by applicable law or agreed to in writing, software │
|
|
│ distributed under the License is distributed on an "AS IS" BASIS, │
|
|
│ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. │
|
|
│ See the License for the specific language governing permissions and │
|
|
│ limitations under the License. │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
#include "third_party/mbedtls/sha1.h"
|
|
#include "libc/intrin/asan.internal.h"
|
|
#include "libc/intrin/bits.h"
|
|
#include "libc/macros.internal.h"
|
|
#include "libc/nexgen32e/sha.h"
|
|
#include "libc/nexgen32e/x86feature.h"
|
|
#include "libc/str/str.h"
|
|
#include "third_party/mbedtls/common.h"
|
|
#include "third_party/mbedtls/endian.h"
|
|
#include "third_party/mbedtls/error.h"
|
|
#include "third_party/mbedtls/md.h"
|
|
#include "third_party/mbedtls/platform.h"
|
|
|
|
asm(".ident\t\"\\n\\n\
|
|
Mbed TLS (Apache 2.0)\\n\
|
|
Copyright ARM Limited\\n\
|
|
Copyright Mbed TLS Contributors\"");
|
|
asm(".include \"libc/disclaimer.inc\"");
|
|
/* clang-format off */
|
|
|
|
/**
|
|
* @fileoverview FIPS-180-1 compliant SHA-1 implementation
|
|
*
|
|
* The SHA-1 standard was published by NIST in 1993.
|
|
*
|
|
* @see http://www.itl.nist.gov/fipspubs/fip180-1.htm
|
|
*/
|
|
|
|
#define SHA1_VALIDATE_RET(cond) \
|
|
MBEDTLS_INTERNAL_VALIDATE_RET( cond, MBEDTLS_ERR_SHA1_BAD_INPUT_DATA )
|
|
|
|
#define SHA1_VALIDATE(cond) MBEDTLS_INTERNAL_VALIDATE( cond )
|
|
|
|
/**
|
|
* \brief This function clones the state of a SHA-1 context.
|
|
*
|
|
* \warning SHA-1 is considered a weak message digest and its use
|
|
* constitutes a security risk. We recommend considering
|
|
* stronger message digests instead.
|
|
*
|
|
* \param dst The SHA-1 context to clone to. This must be initialized.
|
|
* \param src The SHA-1 context to clone from. This must be initialized.
|
|
*
|
|
*/
|
|
void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
|
|
const mbedtls_sha1_context *src )
|
|
{
|
|
SHA1_VALIDATE( dst != NULL );
|
|
SHA1_VALIDATE( src != NULL );
|
|
*dst = *src;
|
|
}
|
|
|
|
/**
|
|
* \brief This function starts a SHA-1 checksum calculation.
|
|
*
|
|
* \warning SHA-1 is considered a weak message digest and its use
|
|
* constitutes a security risk. We recommend considering
|
|
* stronger message digests instead.
|
|
*
|
|
* \param ctx The SHA-1 context to initialize. This must be initialized.
|
|
*
|
|
* \return \c 0 on success.
|
|
* \return A negative error code on failure.
|
|
*
|
|
*/
|
|
int mbedtls_sha1_starts_ret( mbedtls_sha1_context *ctx )
|
|
{
|
|
SHA1_VALIDATE_RET( ctx != NULL );
|
|
ctx->total[0] = 0;
|
|
ctx->total[1] = 0;
|
|
ctx->state[0] = 0x67452301;
|
|
ctx->state[1] = 0xEFCDAB89;
|
|
ctx->state[2] = 0x98BADCFE;
|
|
ctx->state[3] = 0x10325476;
|
|
ctx->state[4] = 0xC3D2E1F0;
|
|
return( 0 );
|
|
}
|
|
|
|
#if !defined(MBEDTLS_SHA1_PROCESS_ALT)
|
|
/**
|
|
* \brief SHA-1 process data block (internal use only).
|
|
*
|
|
* \warning SHA-1 is considered a weak message digest and its use
|
|
* constitutes a security risk. We recommend considering
|
|
* stronger message digests instead.
|
|
*
|
|
* \param ctx The SHA-1 context to use. This must be initialized.
|
|
* \param data The data block being processed. This must be a
|
|
* readable buffer of length \c 64 Bytes.
|
|
*
|
|
* \return \c 0 on success.
|
|
* \return A negative error code on failure.
|
|
*
|
|
*/
|
|
int mbedtls_internal_sha1_process( mbedtls_sha1_context *ctx,
|
|
const unsigned char data[64] )
|
|
{
|
|
SHA1_VALIDATE_RET( ctx != NULL );
|
|
SHA1_VALIDATE_RET( (const unsigned char *)data != NULL );
|
|
|
|
if( X86_HAVE( SHA ) )
|
|
{
|
|
if( IsAsan() )
|
|
{
|
|
__asan_verify( data, 64 );
|
|
__asan_verify( ctx, sizeof(*ctx) );
|
|
}
|
|
sha1_transform_ni( ctx->state, data, 1 );
|
|
return( 0 );
|
|
}
|
|
if( X86_HAVE( BMI ) &&
|
|
X86_HAVE( BMI2 ) &&
|
|
X86_HAVE( AVX2 ) )
|
|
{
|
|
if( IsAsan() )
|
|
{
|
|
__asan_verify( data, 64 );
|
|
__asan_verify( ctx, sizeof(*ctx) );
|
|
}
|
|
sha1_transform_avx2( ctx->state, data, 1 );
|
|
return( 0 );
|
|
}
|
|
|
|
#ifdef MBEDTLS_SHA1_SMALLER
|
|
#define ROL(a, b) ((a << b) | (a >> (32 - b)))
|
|
|
|
uint32_t a, b, c, d, e, i, j, t, m[80];
|
|
for (i = 0, j = 0; i < 16; ++i, j += 4) {
|
|
m[i] = READ32BE(data + j);
|
|
}
|
|
for (; i < 80; ++i) {
|
|
m[i] = (m[i - 3] ^ m[i - 8] ^ m[i - 14] ^ m[i - 16]);
|
|
m[i] = (m[i] << 1) | (m[i] >> 31);
|
|
}
|
|
a = ctx->state[0];
|
|
b = ctx->state[1];
|
|
c = ctx->state[2];
|
|
d = ctx->state[3];
|
|
e = ctx->state[4];
|
|
for (i = 0; i < 20; ++i) {
|
|
t = ROL(a, 5) + ((b & c) ^ (~b & d)) + e + 0x5a827999 + m[i];
|
|
e = d, d = c;
|
|
c = ROL(b, 30);
|
|
b = a, a = t;
|
|
}
|
|
for (; i < 40; ++i) {
|
|
t = ROL(a, 5) + (b ^ c ^ d) + e + 0x6ed9eba1 + m[i];
|
|
e = d, d = c;
|
|
c = ROL(b, 30);
|
|
b = a, a = t;
|
|
}
|
|
for (; i < 60; ++i) {
|
|
t = ROL(a, 5) + ((b & c) ^ (b & d) ^ (c & d)) + e + 0x8f1bbcdc + m[i];
|
|
e = d, d = c;
|
|
c = ROL(b, 30);
|
|
b = a, a = t;
|
|
}
|
|
for (; i < 80; ++i) {
|
|
t = ROL(a, 5) + (b ^ c ^ d) + e + 0xca62c1d6 + m[i];
|
|
e = d, d = c;
|
|
c = ROL(b, 30);
|
|
b = a, a = t;
|
|
}
|
|
ctx->state[0] += a;
|
|
ctx->state[1] += b;
|
|
ctx->state[2] += c;
|
|
ctx->state[3] += d;
|
|
ctx->state[4] += e;
|
|
|
|
mbedtls_platform_zeroize(m, sizeof(m));
|
|
|
|
#else
|
|
|
|
struct
|
|
{
|
|
uint32_t temp, W[16], A, B, C, D, E;
|
|
} local;
|
|
|
|
GET_UINT32_BE( local.W[ 0], data, 0 );
|
|
GET_UINT32_BE( local.W[ 1], data, 4 );
|
|
GET_UINT32_BE( local.W[ 2], data, 8 );
|
|
GET_UINT32_BE( local.W[ 3], data, 12 );
|
|
GET_UINT32_BE( local.W[ 4], data, 16 );
|
|
GET_UINT32_BE( local.W[ 5], data, 20 );
|
|
GET_UINT32_BE( local.W[ 6], data, 24 );
|
|
GET_UINT32_BE( local.W[ 7], data, 28 );
|
|
GET_UINT32_BE( local.W[ 8], data, 32 );
|
|
GET_UINT32_BE( local.W[ 9], data, 36 );
|
|
GET_UINT32_BE( local.W[10], data, 40 );
|
|
GET_UINT32_BE( local.W[11], data, 44 );
|
|
GET_UINT32_BE( local.W[12], data, 48 );
|
|
GET_UINT32_BE( local.W[13], data, 52 );
|
|
GET_UINT32_BE( local.W[14], data, 56 );
|
|
GET_UINT32_BE( local.W[15], data, 60 );
|
|
|
|
#define S(x,n) (((x) << (n)) | (((x) & 0xFFFFFFFF) >> (32 - (n))))
|
|
|
|
#define R(t) \
|
|
( \
|
|
local.temp = local.W[( (t) - 3 ) & 0x0F] ^ \
|
|
local.W[( (t) - 8 ) & 0x0F] ^ \
|
|
local.W[( (t) - 14 ) & 0x0F] ^ \
|
|
local.W[ (t) & 0x0F], \
|
|
( local.W[(t) & 0x0F] = S(local.temp,1) ) \
|
|
)
|
|
|
|
#define P(a,b,c,d,e,x) \
|
|
do \
|
|
{ \
|
|
(e) += S((a),5) + F((b),(c),(d)) + K + (x); \
|
|
(b) = S((b),30); \
|
|
} while( 0 )
|
|
|
|
local.A = ctx->state[0];
|
|
local.B = ctx->state[1];
|
|
local.C = ctx->state[2];
|
|
local.D = ctx->state[3];
|
|
local.E = ctx->state[4];
|
|
|
|
#define F(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
|
|
#define K 0x5A827999
|
|
|
|
P( local.A, local.B, local.C, local.D, local.E, local.W[0] );
|
|
P( local.E, local.A, local.B, local.C, local.D, local.W[1] );
|
|
P( local.D, local.E, local.A, local.B, local.C, local.W[2] );
|
|
P( local.C, local.D, local.E, local.A, local.B, local.W[3] );
|
|
P( local.B, local.C, local.D, local.E, local.A, local.W[4] );
|
|
P( local.A, local.B, local.C, local.D, local.E, local.W[5] );
|
|
P( local.E, local.A, local.B, local.C, local.D, local.W[6] );
|
|
P( local.D, local.E, local.A, local.B, local.C, local.W[7] );
|
|
P( local.C, local.D, local.E, local.A, local.B, local.W[8] );
|
|
P( local.B, local.C, local.D, local.E, local.A, local.W[9] );
|
|
P( local.A, local.B, local.C, local.D, local.E, local.W[10] );
|
|
P( local.E, local.A, local.B, local.C, local.D, local.W[11] );
|
|
P( local.D, local.E, local.A, local.B, local.C, local.W[12] );
|
|
P( local.C, local.D, local.E, local.A, local.B, local.W[13] );
|
|
P( local.B, local.C, local.D, local.E, local.A, local.W[14] );
|
|
P( local.A, local.B, local.C, local.D, local.E, local.W[15] );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(16) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(17) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(18) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(19) );
|
|
|
|
#undef K
|
|
#undef F
|
|
|
|
#define F(x,y,z) ((x) ^ (y) ^ (z))
|
|
#define K 0x6ED9EBA1
|
|
|
|
P( local.A, local.B, local.C, local.D, local.E, R(20) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(21) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(22) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(23) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(24) );
|
|
P( local.A, local.B, local.C, local.D, local.E, R(25) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(26) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(27) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(28) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(29) );
|
|
P( local.A, local.B, local.C, local.D, local.E, R(30) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(31) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(32) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(33) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(34) );
|
|
P( local.A, local.B, local.C, local.D, local.E, R(35) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(36) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(37) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(38) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(39) );
|
|
|
|
#undef K
|
|
#undef F
|
|
|
|
#define F(x,y,z) (((x) & (y)) | ((z) & ((x) | (y))))
|
|
#define K 0x8F1BBCDC
|
|
|
|
P( local.A, local.B, local.C, local.D, local.E, R(40) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(41) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(42) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(43) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(44) );
|
|
P( local.A, local.B, local.C, local.D, local.E, R(45) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(46) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(47) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(48) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(49) );
|
|
P( local.A, local.B, local.C, local.D, local.E, R(50) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(51) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(52) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(53) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(54) );
|
|
P( local.A, local.B, local.C, local.D, local.E, R(55) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(56) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(57) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(58) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(59) );
|
|
|
|
#undef K
|
|
#undef F
|
|
|
|
#define F(x,y,z) ((x) ^ (y) ^ (z))
|
|
#define K 0xCA62C1D6
|
|
|
|
P( local.A, local.B, local.C, local.D, local.E, R(60) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(61) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(62) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(63) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(64) );
|
|
P( local.A, local.B, local.C, local.D, local.E, R(65) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(66) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(67) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(68) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(69) );
|
|
P( local.A, local.B, local.C, local.D, local.E, R(70) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(71) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(72) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(73) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(74) );
|
|
P( local.A, local.B, local.C, local.D, local.E, R(75) );
|
|
P( local.E, local.A, local.B, local.C, local.D, R(76) );
|
|
P( local.D, local.E, local.A, local.B, local.C, R(77) );
|
|
P( local.C, local.D, local.E, local.A, local.B, R(78) );
|
|
P( local.B, local.C, local.D, local.E, local.A, R(79) );
|
|
|
|
#undef K
|
|
#undef F
|
|
|
|
ctx->state[0] += local.A;
|
|
ctx->state[1] += local.B;
|
|
ctx->state[2] += local.C;
|
|
ctx->state[3] += local.D;
|
|
ctx->state[4] += local.E;
|
|
|
|
/* Zeroise buffers and variables to clear sensitive data from memory. */
|
|
mbedtls_platform_zeroize( &local, sizeof( local ) );
|
|
|
|
#endif /* MBEDTLS_SHA1_SMALLER */
|
|
|
|
return( 0 );
|
|
}
|
|
|
|
#endif /* !MBEDTLS_SHA1_PROCESS_ALT */
|
|
|
|
/**
|
|
* \brief This function feeds an input buffer into an ongoing SHA-1
|
|
* checksum calculation.
|
|
*
|
|
* \warning SHA-1 is considered a weak message digest and its use
|
|
* constitutes a security risk. We recommend considering
|
|
* stronger message digests instead.
|
|
*
|
|
* \param ctx The SHA-1 context. This must be initialized
|
|
* and have a hash operation started.
|
|
* \param input The buffer holding the input data.
|
|
* This must be a readable buffer of length \p ilen Bytes.
|
|
* \param ilen The length of the input data \p input in Bytes.
|
|
*
|
|
* \return \c 0 on success.
|
|
* \return A negative error code on failure.
|
|
*/
|
|
int mbedtls_sha1_update_ret( mbedtls_sha1_context *ctx,
|
|
const unsigned char *input,
|
|
size_t ilen )
|
|
{
|
|
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
|
|
uint32_t left;
|
|
size_t n, fill;
|
|
|
|
SHA1_VALIDATE_RET( ctx != NULL );
|
|
SHA1_VALIDATE_RET( ilen == 0 || input != NULL );
|
|
|
|
if( ilen == 0 )
|
|
return( 0 );
|
|
|
|
left = ctx->total[0] & 0x3F;
|
|
fill = 64 - left;
|
|
|
|
ctx->total[0] += (uint32_t) ilen;
|
|
ctx->total[0] &= 0xFFFFFFFF;
|
|
|
|
if( ctx->total[0] < (uint32_t) ilen )
|
|
ctx->total[1]++;
|
|
|
|
if( left && ilen >= fill )
|
|
{
|
|
memcpy( (void *) (ctx->buffer + left), input, fill );
|
|
if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
|
|
return( ret );
|
|
input += fill;
|
|
ilen -= fill;
|
|
left = 0;
|
|
}
|
|
|
|
if( ilen >= 64 )
|
|
{
|
|
if( X86_HAVE( SHA ) )
|
|
{
|
|
if( IsAsan() )
|
|
__asan_verify( input, ilen );
|
|
sha1_transform_ni( ctx->state, input, ilen / 64 );
|
|
input += ROUNDDOWN( ilen, 64 );
|
|
ilen -= ROUNDDOWN( ilen, 64 );
|
|
}
|
|
else if( X86_HAVE( BMI ) &&
|
|
X86_HAVE( BMI2 ) &&
|
|
X86_HAVE( AVX2 ) )
|
|
{
|
|
if( IsAsan() )
|
|
__asan_verify( input, ilen );
|
|
sha1_transform_avx2( ctx->state, input, ilen / 64 );
|
|
input += ROUNDDOWN( ilen, 64 );
|
|
ilen -= ROUNDDOWN( ilen, 64 );
|
|
}
|
|
else
|
|
{
|
|
do
|
|
{
|
|
if(( ret = mbedtls_internal_sha1_process( ctx, input ) ))
|
|
return( ret );
|
|
input += 64;
|
|
ilen -= 64;
|
|
}
|
|
while( ilen >= 64 );
|
|
}
|
|
}
|
|
|
|
if( ilen > 0 )
|
|
memcpy( (void *) (ctx->buffer + left), input, ilen );
|
|
|
|
return( 0 );
|
|
}
|
|
|
|
/**
|
|
* \brief This function finishes the SHA-1 operation, and writes
|
|
* the result to the output buffer.
|
|
*
|
|
* \warning SHA-1 is considered a weak message digest and its use
|
|
* constitutes a security risk. We recommend considering
|
|
* stronger message digests instead.
|
|
*
|
|
* \param ctx The SHA-1 context to use. This must be initialized and
|
|
* have a hash operation started.
|
|
* \param output The SHA-1 checksum result. This must be a writable
|
|
* buffer of length \c 20 Bytes.
|
|
*
|
|
* \return \c 0 on success.
|
|
* \return A negative error code on failure.
|
|
*/
|
|
int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx,
|
|
unsigned char output[20] )
|
|
{
|
|
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
|
|
uint32_t used;
|
|
uint32_t high, low;
|
|
|
|
SHA1_VALIDATE_RET( ctx != NULL );
|
|
SHA1_VALIDATE_RET( (unsigned char *)output != NULL );
|
|
|
|
/*
|
|
* Add padding: 0x80 then 0x00 until 8 bytes remain for the length
|
|
*/
|
|
used = ctx->total[0] & 0x3F;
|
|
|
|
ctx->buffer[used++] = 0x80;
|
|
|
|
if( used <= 56 )
|
|
{
|
|
/* Enough room for padding + length in current block */
|
|
mbedtls_platform_zeroize( ctx->buffer + used, 56 - used );
|
|
}
|
|
else
|
|
{
|
|
/* We'll need an extra block */
|
|
mbedtls_platform_zeroize( ctx->buffer + used, 64 - used );
|
|
if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
|
|
return( ret );
|
|
mbedtls_platform_zeroize( ctx->buffer, 56 );
|
|
}
|
|
|
|
/*
|
|
* Add message length
|
|
*/
|
|
high = ( ctx->total[0] >> 29 )
|
|
| ( ctx->total[1] << 3 );
|
|
low = ( ctx->total[0] << 3 );
|
|
|
|
PUT_UINT32_BE( high, ctx->buffer, 56 );
|
|
PUT_UINT32_BE( low, ctx->buffer, 60 );
|
|
|
|
if( ( ret = mbedtls_internal_sha1_process( ctx, ctx->buffer ) ) != 0 )
|
|
return( ret );
|
|
|
|
/*
|
|
* Output final state
|
|
*/
|
|
PUT_UINT32_BE( ctx->state[0], output, 0 );
|
|
PUT_UINT32_BE( ctx->state[1], output, 4 );
|
|
PUT_UINT32_BE( ctx->state[2], output, 8 );
|
|
PUT_UINT32_BE( ctx->state[3], output, 12 );
|
|
PUT_UINT32_BE( ctx->state[4], output, 16 );
|
|
|
|
return( 0 );
|
|
}
|
|
|
|
/**
|
|
* \brief This function calculates the SHA-1 checksum of a buffer.
|
|
*
|
|
* The function allocates the context, performs the
|
|
* calculation, and frees the context.
|
|
*
|
|
* The SHA-1 result is calculated as
|
|
* output = SHA-1(input buffer).
|
|
*
|
|
* \warning SHA-1 is considered a weak message digest and its use
|
|
* constitutes a security risk. We recommend considering
|
|
* stronger message digests instead.
|
|
*
|
|
* \param input The buffer holding the input data.
|
|
* This must be a readable buffer of length \p ilen Bytes.
|
|
* \param ilen The length of the input data \p input in Bytes.
|
|
* \param output The SHA-1 checksum result.
|
|
* This must be a writable buffer of length \c 20 Bytes.
|
|
*
|
|
* \return \c 0 on success.
|
|
* \return A negative error code on failure.
|
|
*
|
|
*/
|
|
int mbedtls_sha1_ret( const void *input,
|
|
size_t ilen,
|
|
unsigned char output[20] )
|
|
{
|
|
int ret = MBEDTLS_ERR_THIS_CORRUPTION;
|
|
mbedtls_sha1_context ctx;
|
|
SHA1_VALIDATE_RET( ilen == 0 || input != NULL );
|
|
SHA1_VALIDATE_RET( (unsigned char *)output != NULL );
|
|
mbedtls_sha1_init( &ctx );
|
|
if( ( ret = mbedtls_sha1_starts_ret( &ctx ) ) != 0 )
|
|
goto exit;
|
|
if( ( ret = mbedtls_sha1_update_ret( &ctx, input, ilen ) ) != 0 )
|
|
goto exit;
|
|
if( ( ret = mbedtls_sha1_finish_ret( &ctx, output ) ) != 0 )
|
|
goto exit;
|
|
exit:
|
|
mbedtls_sha1_free( &ctx );
|
|
return( ret );
|
|
}
|
|
|
|
const mbedtls_md_info_t mbedtls_sha1_info = {
|
|
"SHA1",
|
|
MBEDTLS_MD_SHA1,
|
|
20,
|
|
64,
|
|
(void *)mbedtls_sha1_starts_ret,
|
|
(void *)mbedtls_sha1_update_ret,
|
|
(void *)mbedtls_internal_sha1_process,
|
|
(void *)mbedtls_sha1_finish_ret,
|
|
(void *)mbedtls_sha1_ret,
|
|
};
|