sha1算法的介绍以及c语言的实现

最新推荐文章于 2024-05-13 19:00:47 发布
最新推荐文章于 2024-05-13 19:00:47 发布
阅读量1.9k 收藏 8
点赞数 1
分类专栏： 网络 安全 文章标签： sha1算法的介绍以及c语言的实现

sha1：安全哈希算法（secure hash algorithm）
加密：将密码嵌入到一串序列值中，通过sha1加密后，生成一段固定长度的散列值（160位）。
解密:解密方同样将密码嵌入到同样的序列值中，同过sha1算法后会生成同样的一串序列值。如果密码不对，算法生成的散列值值就和加密时的散列值肯定不一样。从而实现了加密功能。

该算法的输入长度不限，产生的输出是一个160位的报文摘要。


该算法实现的数字签名的策略：将要传输的明文通过该算法运算生成相应的保温摘要（不同的明文对应不同的报文摘要），将明文和算法生成的报文摘要同时传输到对端，对端接收到明文和报文摘要后，使用该算法将接收到的明文生成相应的报文摘要，将本机生成的报文摘要和接收到的报文摘要相对比，如果不同，说明明文在传输过程中被修改，相同说明明文在传输过程中没有被修改。

sha1.c

/*
 *  FIPS-180-1 compliant SHA-1 implementation
 *
 *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
 *  SPDX-License-Identifier: Apache-2.0
 *
 *  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.
 *
 *  This file is part of mbed TLS (https://tls.mbed.org)
 */
/*
 *  The SHA-1 standard was published by NIST in 1993.
 *
 *  http://www.itl.nist.gov/fipspubs/fip180-1.htm
 */

#if !defined(MBEDTLS_CONFIG_FILE)
#include "mbedtls/config.h"
#else
#include MBEDTLS_CONFIG_FILE
#endif

#if defined(MBEDTLS_SHA1_C)

#include "mbedtls/sha1.h"

#include <string.h>

#if defined(MBEDTLS_SELF_TEST)
#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdio.h>
#define mbedtls_printf printf
#endif /* MBEDTLS_PLATFORM_C */
#endif /* MBEDTLS_SELF_TEST */

#if !defined(MBEDTLS_SHA1_ALT)

/* Implementation that should never be optimized out by the compiler */
static void mbedtls_zeroize( void *v, size_t n ) {
    volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
}

/*
 * 32-bit integer manipulation macros (big endian)
 */
#ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i)                            \
{                                                       \
    (n) = ( (uint32_t) (b)[(i)    ] << 24 )             \
        | ( (uint32_t) (b)[(i) + 1] << 16 )             \
        | ( (uint32_t) (b)[(i) + 2] <<  8 )             \
        | ( (uint32_t) (b)[(i) + 3]       );            \
}
#endif

#ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i)                            \
{                                                       \
    (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
    (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
    (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
    (b)[(i) + 3] = (unsigned char) ( (n)       );       \
}
#endif

void mbedtls_sha1_init( mbedtls_sha1_context *ctx )
{
    memset( ctx, 0, sizeof( mbedtls_sha1_context ) );
}

void mbedtls_sha1_free( mbedtls_sha1_context *ctx )
{
    if( ctx == NULL )
        return;

    mbedtls_zeroize( ctx, sizeof( mbedtls_sha1_context ) );
}

void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
                         const mbedtls_sha1_context *src )
{
    *dst = *src;
}

/*
 * SHA-1 context setup
 */
void mbedtls_sha1_starts( mbedtls_sha1_context *ctx )
{
    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;
}

#if !defined(MBEDTLS_SHA1_PROCESS_ALT)
void mbedtls_sha1_process( mbedtls_sha1_context *ctx, const unsigned char data[64] )
{
    uint32_t temp, W[16], A, B, C, D, E;

    GET_UINT32_BE( W[ 0], data,  0 );
    GET_UINT32_BE( W[ 1], data,  4 );
    GET_UINT32_BE( W[ 2], data,  8 );
    GET_UINT32_BE( W[ 3], data, 12 );
    GET_UINT32_BE( W[ 4], data, 16 );
    GET_UINT32_BE( W[ 5], data, 20 );
    GET_UINT32_BE( W[ 6], data, 24 );
    GET_UINT32_BE( W[ 7], data, 28 );
    GET_UINT32_BE( W[ 8], data, 32 );
    GET_UINT32_BE( W[ 9], data, 36 );
    GET_UINT32_BE( W[10], data, 40 );
    GET_UINT32_BE( W[11], data, 44 );
    GET_UINT32_BE( W[12], data, 48 );
    GET_UINT32_BE( W[13], data, 52 );
    GET_UINT32_BE( W[14], data, 56 );
    GET_UINT32_BE( W[15], data, 60 );

#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))

#define R(t)                                            \
(                                                       \
    temp = W[( t -  3 ) & 0x0F] ^ W[( t - 8 ) & 0x0F] ^ \
           W[( t - 14 ) & 0x0F] ^ W[  t       & 0x0F],  \
    ( W[t & 0x0F] = S(temp,1) )                         \
)

#define P(a,b,c,d,e,x)                                  \
{                                                       \
    e += S(a,5) + F(b,c,d) + K + x; b = S(b,30);        \
}

    A = ctx->state[0];
    B = ctx->state[1];
    C = ctx->state[2];
    D = ctx->state[3];
    E = ctx->state[4];

#define F(x,y,z) (z ^ (x & (y ^ z)))
#define K 0x5A827999

    P( A, B, C, D, E, W[0]  );
    P( E, A, B, C, D, W[1]  );
    P( D, E, A, B, C, W[2]  );
    P( C, D, E, A, B, W[3]  );
    P( B, C, D, E, A, W[4]  );
    P( A, B, C, D, E, W[5]  );
    P( E, A, B, C, D, W[6]  );
    P( D, E, A, B, C, W[7]  );
    P( C, D, E, A, B, W[8]  );
    P( B, C, D, E, A, W[9]  );
    P( A, B, C, D, E, W[10] );
    P( E, A, B, C, D, W[11] );
    P( D, E, A, B, C, W[12] );
    P( C, D, E, A, B, W[13] );
    P( B, C, D, E, A, W[14] );
    P( A, B, C, D, E, W[15] );
    P( E, A, B, C, D, R(16) );
    P( D, E, A, B, C, R(17) );
    P( C, D, E, A, B, R(18) );
    P( B, C, D, E, A, R(19) );

#undef K
#undef F

#define F(x,y,z) (x ^ y ^ z)
#define K 0x6ED9EBA1

    P( A, B, C, D, E, R(20) );
    P( E, A, B, C, D, R(21) );
    P( D, E, A, B, C, R(22) );
    P( C, D, E, A, B, R(23) );
    P( B, C, D, E, A, R(24) );
    P( A, B, C, D, E, R(25) );
    P( E, A, B, C, D, R(26) );
    P( D, E, A, B, C, R(27) );
    P( C, D, E, A, B, R(28) );
    P( B, C, D, E, A, R(29) );
    P( A, B, C, D, E, R(30) );
    P( E, A, B, C, D, R(31) );
    P( D, E, A, B, C, R(32) );
    P( C, D, E, A, B, R(33) );
    P( B, C, D, E, A, R(34) );
    P( A, B, C, D, E, R(35) );
    P( E, A, B, C, D, R(36) );
    P( D, E, A, B, C, R(37) );
    P( C, D, E, A, B, R(38) );
    P( B, C, D, E, A, R(39) );

#undef K
#undef F

#define F(x,y,z) ((x & y) | (z & (x | y)))
#define K 0x8F1BBCDC

    P( A, B, C, D, E, R(40) );
    P( E, A, B, C, D, R(41) );
    P( D, E, A, B, C, R(42) );
    P( C, D, E, A, B, R(43) );
    P( B, C, D, E, A, R(44) );
    P( A, B, C, D, E, R(45) );
    P( E, A, B, C, D, R(46) );
    P( D, E, A, B, C, R(47) );
    P( C, D, E, A, B, R(48) );
    P( B, C, D, E, A, R(49) );
    P( A, B, C, D, E, R(50) );
    P( E, A, B, C, D, R(51) );
    P( D, E, A, B, C, R(52) );
    P( C, D, E, A, B, R(53) );
    P( B, C, D, E, A, R(54) );
    P( A, B, C, D, E, R(55) );
    P( E, A, B, C, D, R(56) );
    P( D, E, A, B, C, R(57) );
    P( C, D, E, A, B, R(58) );
    P( B, C, D, E, A, R(59) );

#undef K
#undef F

#define F(x,y,z) (x ^ y ^ z)
#define K 0xCA62C1D6

    P( A, B, C, D, E, R(60) );
    P( E, A, B, C, D, R(61) );
    P( D, E, A, B, C, R(62) );
    P( C, D, E, A, B, R(63) );
    P( B, C, D, E, A, R(64) );
    P( A, B, C, D, E, R(65) );
    P( E, A, B, C, D, R(66) );
    P( D, E, A, B, C, R(67) );
    P( C, D, E, A, B, R(68) );
    P( B, C, D, E, A, R(69) );
    P( A, B, C, D, E, R(70) );
    P( E, A, B, C, D, R(71) );
    P( D, E, A, B, C, R(72) );
    P( C, D, E, A, B, R(73) );
    P( B, C, D, E, A, R(74) );
    P( A, B, C, D, E, R(75) );
    P( E, A, B, C, D, R(76) );
    P( D, E, A, B, C, R(77) );
    P( C, D, E, A, B, R(78) );
    P( B, C, D, E, A, R(79) );

#undef K
#undef F

    ctx->state[0] += A;
    ctx->state[1] += B;
    ctx->state[2] += C;
    ctx->state[3] += D;
    ctx->state[4] += E;
}
#endif /* !MBEDTLS_SHA1_PROCESS_ALT */

/*
 * SHA-1 process buffer
 */
void mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen )
{
    size_t fill;
    uint32_t left;

    if( ilen == 0 )
        return;

    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 );
        mbedtls_sha1_process( ctx, ctx->buffer );
        input += fill;
        ilen  -= fill;
        left = 0;
    }

    while( ilen >= 64 )
    {
        mbedtls_sha1_process( ctx, input );
        input += 64;
        ilen  -= 64;
    }

    if( ilen > 0 )
        memcpy( (void *) (ctx->buffer + left), input, ilen );
}

static const unsigned char sha1_padding[64] =
{
 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

/*
 * SHA-1 final digest
 */
void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] )
{
    uint32_t last, padn;
    uint32_t high, low;
    unsigned char msglen[8];

    high = ( ctx->total[0] >> 29 )
         | ( ctx->total[1] <<  3 );
    low  = ( ctx->total[0] <<  3 );

    PUT_UINT32_BE( high, msglen, 0 );
    PUT_UINT32_BE( low,  msglen, 4 );

    last = ctx->total[0] & 0x3F;
    padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );

    mbedtls_sha1_update( ctx, sha1_padding, padn );
    mbedtls_sha1_update( ctx, msglen, 8 );

    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 );
}

#endif /* !MBEDTLS_SHA1_ALT */

/*
 * output = SHA-1( input buffer )
 */
void mbedtls_sha1( const unsigned char *input, size_t ilen, unsigned char output[20] )
{
    mbedtls_sha1_context ctx;

    mbedtls_sha1_init( &ctx );
    mbedtls_sha1_starts( &ctx );
    mbedtls_sha1_update( &ctx, input, ilen );
    mbedtls_sha1_finish( &ctx, output );
    mbedtls_sha1_free( &ctx );
}

#if defined(MBEDTLS_SELF_TEST)
/*
 * FIPS-180-1 test vectors
 */
static const unsigned char sha1_test_buf[3][57] =
{
    { "abc" },
    { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" },
    { "" }
};

static const int sha1_test_buflen[3] =
{
    3, 56, 1000
};

static const unsigned char sha1_test_sum[3][20] =
{
    { 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E,
      0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D },
    { 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE,
      0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 },
    { 0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E,
      0xEB, 0x2B, 0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F }
};

/*
 * Checkup routine
 */
int mbedtls_sha1_self_test( int verbose )
{
    int i, j, buflen, ret = 0;
    unsigned char buf[1024];
    unsigned char sha1sum[20];
    mbedtls_sha1_context ctx;

    mbedtls_sha1_init( &ctx );

    /*
     * SHA-1
     */
    for( i = 0; i < 3; i++ )
    {
        if( verbose != 0 )
            mbedtls_printf( "  SHA-1 test #%d: ", i + 1 );

        mbedtls_sha1_starts( &ctx );

        if( i == 2 )
        {
            memset( buf, 'a', buflen = 1000 );

            for( j = 0; j < 1000; j++ )
                mbedtls_sha1_update( &ctx, buf, buflen );
        }
        else
            mbedtls_sha1_update( &ctx, sha1_test_buf[i],
                               sha1_test_buflen[i] );

        mbedtls_sha1_finish( &ctx, sha1sum );

        if( memcmp( sha1sum, sha1_test_sum[i], 20 ) != 0 )
        {
            if( verbose != 0 )
                mbedtls_printf( "failed\n" );

            ret = 1;
            goto exit;
        }

        if( verbose != 0 )
            mbedtls_printf( "passed\n" );
    }

    if( verbose != 0 )
        mbedtls_printf( "\n" );

exit:
    mbedtls_sha1_free( &ctx );

    return( ret );
}

#endif /* MBEDTLS_SELF_TEST */

#endif /* MBEDTLS_SHA1_C */

 sha1.h

/**
 * \file sha1.h
 *
 * \brief SHA-1 cryptographic hash function
 *
 *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
 *  SPDX-License-Identifier: Apache-2.0
 *
 *  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.
 *
 *  This file is part of mbed TLS (https://tls.mbed.org)
 */
#ifndef MBEDTLS_SHA1_H
#define MBEDTLS_SHA1_H

#if !defined(MBEDTLS_CONFIG_FILE)
#include "config.h"
#else
#include MBEDTLS_CONFIG_FILE
#endif

#include <stddef.h>
#include <stdint.h>

#if !defined(MBEDTLS_SHA1_ALT)
// Regular implementation
//

#ifdef __cplusplus
extern "C" {
#endif

/**
 * \brief          SHA-1 context structure
 */
typedef struct
{
    uint32_t total[2];          /*!< number of bytes processed  */
    uint32_t state[5];          /*!< intermediate digest state  */
    unsigned char buffer[64];   /*!< data block being processed */
}
mbedtls_sha1_context;

/**
 * \brief          Initialize SHA-1 context
 *
 * \param ctx      SHA-1 context to be initialized
 */
void mbedtls_sha1_init( mbedtls_sha1_context *ctx );

/**
 * \brief          Clear SHA-1 context
 *
 * \param ctx      SHA-1 context to be cleared
 */
void mbedtls_sha1_free( mbedtls_sha1_context *ctx );

/**
 * \brief          Clone (the state of) a SHA-1 context
 *
 * \param dst      The destination context
 * \param src      The context to be cloned
 */
void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
                         const mbedtls_sha1_context *src );

/**
 * \brief          SHA-1 context setup
 *
 * \param ctx      context to be initialized
 */
void mbedtls_sha1_starts( mbedtls_sha1_context *ctx );

/**
 * \brief          SHA-1 process buffer
 *
 * \param ctx      SHA-1 context
 * \param input    buffer holding the  data
 * \param ilen     length of the input data
 */
void mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen );

/**
 * \brief          SHA-1 final digest
 *
 * \param ctx      SHA-1 context
 * \param output   SHA-1 checksum result
 */
void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] );

/* Internal use */
void mbedtls_sha1_process( mbedtls_sha1_context *ctx, const unsigned char data[64] );

#ifdef __cplusplus
}
#endif

#else  /* MBEDTLS_SHA1_ALT */
#include "sha1_alt.h"
#endif /* MBEDTLS_SHA1_ALT */

#ifdef __cplusplus
extern "C" {
#endif

/**
 * \brief          Output = SHA-1( input buffer )
 *
 * \param input    buffer holding the  data
 * \param ilen     length of the input data
 * \param output   SHA-1 checksum result
 */
void mbedtls_sha1( const unsigned char *input, size_t ilen, unsigned char output[20] );

/**
 * \brief          Checkup routine
 *
 * \return         0 if successful, or 1 if the test failed
 */
int mbedtls_sha1_self_test( int verbose );

#ifdef __cplusplus
}
#endif

#endif /* mbedtls_sha1.h */

 

酸菜鱼的鱼
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SHA1算法 C语言实现
Blackkitty 's Blog
02-20 1万+
SHA1算法 C语言实现实现了计算字符串，文件的SHA1值 算法来自百度百科 VS2013下成功编译运行
SHA-1算法c语言实现
无知人生，记录点滴
05-14 2122
安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准 （Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化...
安全哈希算法(sha1)c语言实现，包括测试程序
04-15
全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要
SHA1算法的C语言实现（支持输入字符串长度超过56）_sha1 c语言(1)
最新发布
2301_79655576的博客
05-13 192
void SHA1_group(unsigned char input[64], unsigned long hash[5]) // 对512位的消息组进行加密。void SHA1(unsigned char *input, unsigned long hash[5]) // SHA1算法。// 将原始明文进行分组。// 明文组数 - 1。
SHA1hash算法C语言实现
mlynb的博客
12-03 5725
SHA的简介 美国国家标准技术研究所NIST于1993年开发的另一个散 列算法称为SHA。两年之后，这个算法被修改为了今天广泛 使用的形式。修改后的版本是SHA-1，是数字签名标准中要 求使用的算法。 SHA接受任何有限长度的输入消息，并产生长度为160比 特的Hash值（MD5仅仅生成128位的摘要），因此抗穷举性 更好。SHA-1设计时基于和MD4相同原理，它有5个参与运 算的32位寄存器字，消息分组和填充方式与MD5相同，主循 环也同样是4轮，但每轮进行20次操作，非线性运算、移位和 加法运算也与MD
SHA1算法的C语言实现（支持输入字符串长度超过56）
m0_54849976的博客
07-27 1072
支持输入字符串长度超过56字节的SHA1算法的C语言实现
maven jar包安全性说明
weixin_45209491的博客
05-15 552
1).说明:文件在进行数据传输时,如何保证安全性可靠性 ​ 2).实现策略:采用sha1加密方式保证传输正确性. ​ 3).sha1算法: ​ SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。 4).数据传输的原理 信息摘要, 目的判断新旧
Sha1算法c语言实现
03-20
在C语言中实现SHA1算法通常包括以下几个步骤： 1. **初始化变量**：首先，需要初始化几个中间变量，它们在计算过程中存储中间结果。这些变量包括五个32位的整数，分别用A、B、C、D和E表示，初始值由SHA1规范给出。 ...
SHA256 哈希密码算法C语言实现
10-10
压缩包中的文件"SHA256"可能包含了C语言实现的SHA256算法的源代码文件，可能还包括编译脚本、测试用例和文档等。要使用这个实现，你需要将其解压并编译源代码，然后在你的程序中调用生成的库或可执行文件，将待哈希...
sha256 哈希算法 c语言实现
08-10
亲测可要使用 * Filename: sha256.c * Author: Brad Conte (brad AT bradconte.com) * Copyright: * Disclaimer: This code is presented "as is" without any guarantees.
Sha256算法c语言实现
03-20
在压缩包中的`Sha256`文件很可能是实现了SHA-256算法的C语言源代码，包含上述步骤的详细实现。通过阅读和理解这段代码，可以深入了解SHA-256的工作原理，并学习如何在实际项目中应用这种强大的安全工具。
sha-1 填充算法C语言实现
05-30
sha-1 填充算法C语言实现版本，亲测可用
用C语言实现SHA－1算法
04-23
用C语言实现SHA－1算法 用C语言实现SHA－1算法 用C语言实现SHA－1算法用C语言实现SHA－1算法 用C语言实现SHA－1算法
SHA1算法实现，c语言实现
05-26
SHA1加密算法
c 语言常见的加密算法——SHA-1算法
A185822153的专栏
12-09 1173
以上这些算法在C语言中实现时，通常会使用到openssl这样的第三方库，因为这些库已经实现了这些算法的高效实现，直接使用。最后，我们输出哈希值（以16进制格式）。请注意，这只是一个简单的示例，实际应用中可能需要更复杂的错误处理和资源管理。在这个示例中，我们首先定义了要计算哈希的数据，然后声明了一个长度为。函数对数据进行哈希计算，并将结果存储在。的数组来存储哈希结果。
【密码学】C 语言实现 SHA-1 填充和数据扩充
SunJ3t的菠萝屋
08-09 3118
Hash函数，一般翻译做”散列”，也有直接音译为”哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
SHA1校验算法C语言实现
热门推荐
coding__madman的博客
07-31 1万+
SHA1 安全哈希算法：对于长度小于2^64位的消息(1M = 1024k,1K = 1024字节，1BYTE = 8bit 可以想象一下2的63次方位可以表示一个多大的数据文件)，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。 SHA1有如下特性：不可以从消息摘要中复原信
C语言获取文件SHA1哈希
weixin_33895657的博客
10-14 163
安全散列算法（Secure Hash Algorithm）主要适用于数字签名标准 （Digital Signature Standard DSS）它定义了数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息。SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要能够用来验证数据的完整性。在传输的过程中。数据非常可能会发生...
SHA1算法 c语言(参考其他修改)
wzxiaodu的专栏
03-25 1835
https://www.cnblogs.com/scu-cjx/p/6878853.html 原来MD5和SHA1分组是不一样的。大小端区别。 #define _CRT_SECURE_NO_WARNINGS #ifndef SHA1_H #define SHA1_H #include <stdio.h> #include <string.h> #include <stdlib.h> #include <math.h> #ifdef __cplu
sha-1算法的c语言实现
05-16
以下是SHA-1算法的C语言实现，包含了初始化、填充、转换和输出四个步骤： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> #define SHA1_BLOCK_SIZE 20 // SHA-1 functions #define SHA1_ROTLEFT(a,b) (((a) << (b)) | ((a) >> (32-(b)))) #define SHA1_ROTRIGHT(a,b) (((a) >> (b)) | ((a) << (32-(b)))) #define SHA1_CH(x,y,z) (((x) & (y)) ^ (~(x) & (z))) #define SHA1_MAJ(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) #define SHA1_E0(x) (SHA1_ROTRIGHT(x, 2) ^ SHA1_ROTRIGHT(x, 13) ^ SHA1_ROTRIGHT(x, 22)) #define SHA1_E1(x) (SHA1_ROTRIGHT(x, 6) ^ SHA1_ROTRIGHT(x, 11) ^ SHA1_ROTRIGHT(x, 25)) #define SHA1_F0(x) (SHA1_ROTRIGHT(x, 7) ^ SHA1_ROTRIGHT(x, 18) ^ ((x) >> 3)) #define SHA1_F1(x) (SHA1_ROTRIGHT(x, 17) ^ SHA1_ROTRIGHT(x, 19) ^ ((x) >> 10)) void sha1_transform(uint32_t *state, const uint8_t *buffer) { uint32_t a, b, c, d, e, temp; uint32_t w[80]; int i; // Copy buffer to work array for (i = 0; i < 16; i++) { w[i] = ((uint32_t)buffer[i * 4]) << 24; w[i] |= ((uint32_t)buffer[i * 4 + 1]) << 16; w[i] |= ((uint32_t)buffer[i * 4 + 2]) << 8; w[i] |= ((uint32_t)buffer[i * 4 + 3]); } for (i = 16; i < 80; i++) { w[i] = SHA1_ROTLEFT(w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16], 1); } a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4]; for (i = 0; i < 20; i++) { temp = SHA1_ROTLEFT(a, 5) + SHA1_CH(b, c, d) + e + w[i] + 0x5a827999; e = d; d = c; c = SHA1_ROTLEFT(b, 30); b = a; a = temp; } for (i = 20; i < 40; i++) { temp = SHA1_ROTLEFT(a, 5) + SHA1_MAJ(b, c, d) + e + w[i] + 0x6ed9eba1; e = d; d = c; c = SHA1_ROTLEFT(b, 30); b = a; a = temp; } for (i = 40; i < 60; i++) { temp = SHA1_ROTLEFT(a, 5) + SHA1_CH(b, c, d) + e + w[i] + 0x8f1bbcdc; e = d; d = c; c = SHA1_ROTLEFT(b, 30); b = a; a = temp; } for (i = 60; i < 80; i++) { temp = SHA1_ROTLEFT(a, 5) + SHA1_MAJ(b, c, d) + e + w[i] + 0xca62c1d6; e = d; d = c; c = SHA1_ROTLEFT(b, 30); b = a; a = temp; } state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e; } void sha1_init(uint32_t *state) { state[0] = 0x67452301; state[1] = 0xefcdab89; state[2] = 0x98badcfe; state[3] = 0x10325476; state[4] = 0xc3d2e1f0; } void sha1_pad(uint8_t *buffer, int len) { int i; buffer[len] = 0x80; for (i = len + 1; i % 64 != 56; i++) { buffer[i] = 0x00; } len *= 8; buffer[i++] = (len >> 56) & 0xff; buffer[i++] = (len >> 48) & 0xff; buffer[i++] = (len >> 40) & 0xff; buffer[i++] = (len >> 32) & 0xff; buffer[i++] = (len >> 24) & 0xff; buffer[i++] = (len >> 16) & 0xff; buffer[i++] = (len >> 8) & 0xff; buffer[i++] = len & 0xff; } void sha1_digest(const uint32_t *state, uint8_t *hash) { int i; for (i = 0; i < 5; i++) { hash[i * 4] = (state[i] >> 24) & 0xff; hash[i * 4 + 1] = (state[i] >> 16) & 0xff; hash[i * 4 + 2] = (state[i] >> 8) & 0xff; hash[i * 4 + 3] = state[i] & 0xff; } } void sha1(const uint8_t *data, int len, uint8_t *hash) { uint32_t state[5]; uint8_t buffer[64]; int i; sha1_init(state); for (i = 0; i < len / 64; i++) { memcpy(buffer, data + i * 64, 64); sha1_transform(state, buffer); } memcpy(buffer, data + i * 64, len % 64); sha1_pad(buffer, len % 64); sha1_transform(state, buffer); sha1_digest(state, hash); } int main() { uint8_t data[] = "hello world"; uint8_t hash[SHA1_BLOCK_SIZE]; sha1(data, strlen((char*)data), hash); printf("SHA1 hash of \"%s\": ", data); for (int i = 0; i < SHA1_BLOCK_SIZE; i++) { printf("%02x", hash[i]); } printf("\n"); return 0; } ``` 在这个实现中，`sha1()`函数接受一个输入数据和长度，以及一个输出缓冲区，将计算出的SHA-1摘要存储在缓冲区中。主函数演示了如何使用该函数计算数据的SHA-1摘要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值