在线观看www成人影院-在线观看www日本免费网站-在线观看www视频-在线观看操-欧美18在线-欧美1级

0
  • 聊天消息
  • 系統消息
  • 評論與回復
登錄后你可以
  • 下載海量資料
  • 學習在線課程
  • 觀看技術視頻
  • 寫文章/發帖/加入社區
會員中心
創作中心

完善資料讓更多小伙伴認識你,還能領取20積分哦,立即完善>

3天內不再提示

【安全算法之SHA1】SHA1摘要運算的C語言源碼實現

嵌入式物聯網開發 ? 來源: 嵌入式物聯網開發 ? 作者: 嵌入式物聯網開發 ? 2022-10-31 10:42 ? 次閱讀

【安全算法之SHA1】SHA1摘要運算的C語言源碼實現

  • 概述
  • 頭文件定義
  • C語言版本的實現源碼
  • 測試用例
  • github倉庫
  • 更多參考鏈接

概述

大家都知道摘要算法在安全領域,也是一個特別重要的存在,而SHA1是其中比較常見的一種摘要算法,它的特點就是計算復雜度較低,不等長的數據原文輸入,可以得出等長的摘要值,這個值是固定為20字節。正是由于這種特殊性,很多重要的數據完整性校驗領域,都可以看到SHA1的影子。
今天給大家帶來SHA1的C源碼版本實現,歡迎大家深入學習和討論。

頭文件定義

頭文件定義如下,主要定義了SHA1的上下文結構體,以及導出的三個API


#ifndef __SHA1_H__
#define __SHA1_H__

#include 

#define SHA1_DIGEST_LEN 20         	// SHA1 outputs a 20 byte digest

typedef struct _sha1_ctx_t {
    uint32_t 		total[2];     	/*!< number of bytes processed  */
    uint32_t 		state[5];   	/*!< intermediate digest state  */
    uint8_t 		buffer[64];   	/*!< data block being processed */
} sha1_ctx_t;

void crypto_sha1_init(sha1_ctx_t *ctx);
void crypto_sha1_update(sha1_ctx_t *ctx, const uint8_t *data, uint32_t len);
void crypto_sha1_final(sha1_ctx_t *ctx, uint8_t *digest);

#endif   // __SHA1_H__

C語言版本的實現源碼

下面是SHA1的C語言版本實現,主要也是圍繞導出的3個API:


#include 
#include "sha1.h"

/*
 * 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)]     = (uint8_t)((n) >> 24);    \
        (b)[(i) + 1] = (uint8_t)((n) >> 16);    \
        (b)[(i) + 2] = (uint8_t)((n) >> 8);     \
        (b)[(i) + 3] = (uint8_t)((n));          \
    }
#endif

static const uint8_t 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
};

static void local_sha1_process(sha1_ctx_t *ctx,
                      const uint8_t   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;
}

/*
 * SHA-1 process init
 */
void crypto_sha1_init(sha1_ctx_t *ctx)
{
    memset(ctx, 0, sizeof(sha1_ctx_t));
    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;
}

/*
 * SHA-1 process buffer
 */
void crypto_sha1_update(sha1_ctx_t *ctx, const uint8_t *input,
                     uint32_t ilen)
{
    uint32_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);
        local_sha1_process(ctx, ctx->buffer);
        input += fill;
        ilen -= fill;
        left = 0;
    }

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

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

/*
 * SHA-1 final digest
 */
void crypto_sha1_final(sha1_ctx_t *ctx, uint8_t *digest)
{
    uint32_t      last, padn;
    uint32_t      high, low;
    uint8_t 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);

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

    PUT_UINT32_BE(ctx->state[0], digest, 0);
    PUT_UINT32_BE(ctx->state[1], digest, 4);
    PUT_UINT32_BE(ctx->state[2], digest, 8);
    PUT_UINT32_BE(ctx->state[3], digest, 12);
    PUT_UINT32_BE(ctx->state[4], digest, 16);
}

測試用例

針對SHA1導出的三個接口,我編寫了以下測試用例:


#include 
#include 

#include "sha1.h"
#include "convert.h"

int log_hexdump(const char *title, const unsigned char *data, int len)
{
    char str[160], octet[10];
    int ofs, i, k, d;
    const unsigned char *buf = (const unsigned char *)data;
    const char dimm[] = "+------------------------------------------------------------------------------+";

    printf("%s (%d bytes):\r\n", title, len);
    printf("%s\r\n", dimm);
    printf("| Offset  : 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F   0123456789ABCDEF |\r\n");
    printf("%s\r\n", dimm);

    for (ofs = 0; ofs < (int)len; ofs += 16) {
        d = snprintf( str, sizeof(str), "| %08X: ", ofs );

        for (i = 0; i < 16; i++) {
            if ((i + ofs) < (int)len) {
                snprintf( octet, sizeof(octet), "%02X ", buf[ofs + i] );
            } else {
                snprintf( octet, sizeof(octet), "   " );
            }

            d += snprintf( &str[d], sizeof(str) - d, "%s", octet );
        }
        d += snprintf( &str[d], sizeof(str) - d, "  " );
        k = d;

        for (i = 0; i < 16; i++) {
            if ((i + ofs) < (int)len) {
                str[k++] = (0x20 <= (buf[ofs + i]) &&  (buf[ofs + i]) <= 0x7E) ? buf[ofs + i] : '.';
            } else {
                str[k++] = ' ';
            }
        }

        str[k] = '\0';
        printf("%s |\r\n", str);
    }

    printf("%s\r\n", dimm);

    return 0;
}

int main(int argc, const char *argv[])
{
	const char *data = "C1D0F8FB4958670DBA40AB1F3752EF0D";
    const char *digest_exp_str = "B36BFDB04A31F6C55E0D592B8F2D3219FBC2424D";
	uint8_t digest_calc[SHA1_DIGEST_LEN];
    uint8_t digest_exp_hex[SHA1_DIGEST_LEN];
	sha1_ctx_t ctx;
	const char *p_calc = data;
	uint8_t data_bytes[128];
	uint16_t len_bytes;
	char data_str[128];

	if (argc > 1) {
		p_calc = argv[1];
	}

	utils_hex_string_2_bytes(data, data_bytes, &len_bytes);
	log_hexdump("data_bytes", data_bytes, len_bytes);
	utils_bytes_2_hex_string(data_bytes, len_bytes, data_str);
	printf("data_str: %s\n", data_str);
	if (!strcmp(data, data_str)) {
		printf("hex string - bytes convert OK\n");
	} else {
		printf("hex string - bytes convert FAIL\n");
	}

	crypto_sha1_init(&ctx);
	crypto_sha1_update(&ctx, (uint8_t *)p_calc, strlen(p_calc));
	crypto_sha1_final(&ctx, digest_calc);

    utils_hex_string_2_bytes(digest_exp_str, digest_exp_hex, &len_bytes);
	if (len_bytes == sizeof(digest_calc) && !memcmp(digest_calc, digest_exp_hex, sizeof(digest_calc))) {
		printf("SHA1 digest test OK\n");
        log_hexdump("digest_calc", digest_calc, sizeof(digest_calc));
	} else {
		log_hexdump("digest_calc", digest_calc, sizeof(digest_calc));
		log_hexdump("digest_exp", digest_exp_hex, sizeof(digest_exp_hex));
		printf("SHA1 digest test FAIL\n");
	}

	return 0;
}

測試用例比較簡單,就是對字符串C1D0F8FB4958670DBA40AB1F3752EF0D進行SHA1運算,期望的摘要結果的hexstring是B36BFDB04A31F6C55E0D592B8F2D3219FBC2424D,這個期望值是用算法工具算出來的。
先用API接口算出摘要值,再與期望值比較,這里有個hexstringtobyte的轉換,如果比較一致則表示API計算OK;反之,接口計算失敗。
同時,也歡迎大家設計提供更多的測試案例代碼。

github倉庫

以上代碼和測試用例,及編譯運行等,可以參考我的github倉庫,有詳細的流程介紹,歡迎大家交流討論。如果有幫助到你的話,記得幫忙點亮一顆星哦。

更多參考鏈接

[1] 【安全算法的github倉庫】
[2] 【安全算法之概述】一文帶你簡要了解常見常用的安全算法

審核編輯 黃昊宇

聲明:本文內容及配圖由入駐作者撰寫或者入駐合作網站授權轉載。文章觀點僅代表作者本人,不代表電子發燒友網立場。文章及其配圖僅供工程師學習之用,如有內容侵權或者其他違規問題,請聯系本站處理。 舉報投訴
  • C語言
    +關注

    關注

    180

    文章

    7613

    瀏覽量

    137245
  • 嵌入式技術
    +關注

    關注

    10

    文章

    360

    瀏覽量

    36373
  • 源碼
    +關注

    關注

    8

    文章

    649

    瀏覽量

    29311
收藏 人收藏

    評論

    相關推薦

    RAKsmart作為i2Coalition聯合創始發起SHA:推動全球托管服務安全

    RAKsmart作為i2Coalition聯合創始發起SHA:推動全球托管服務安全
    的頭像 發表于 01-10 16:25 ?109次閱讀

    【RA-Eco-RA4E2-64PIN-V1.0開發板試用】RA4E2使用之SHA256加密解密

    Hash Algorithm 2)的縮寫,一種密碼散列函數算法標準,由美國國家安全局研發,屬于SHA算法之一,是SHA-1的后繼者。
    發表于 12-23 18:18

    單總線加密芯片和帶有SHA-1引擎保護的1Kb單總線EEPROM-GX28E01-100

    ? 產品概述 GX28E01-100將1024位EEPROM和使用ISO/IEC10118-3 安全散列算法SHA-1)的詢問-應答認證安全性相結合。 該芯片可以處理64位和320位
    的頭像 發表于 11-15 10:39 ?302次閱讀
    單總線加密芯片和帶有<b class='flag-5'>SHA-1</b>引擎保護的<b class='flag-5'>1</b>Kb單總線EEPROM-GX28E01-100

    技術干貨驛站 ▏解鎖C語言高效編程秘訣:深入解析運算符與優先級

    C語言的學習過程中,運算符的使用是不可忽視的重要環節。本文將繼續深入探討C語言中的運算符,重點
    的頭像 發表于 10-13 08:09 ?307次閱讀
    技術干貨驛站 ▏解鎖<b class='flag-5'>C</b><b class='flag-5'>語言</b>高效編程秘訣:深入解析<b class='flag-5'>運算</b>符與優先級

    技術干貨驛站 ▏深入理解C語言:編程高手必備,全方位解析運算符的核心技能!

    C語言的編程領域中,運算符是實現數據處理與邏輯操作的關鍵工具。無論是在處理簡單的數值計算,還是在構建復雜的邏輯結構時,運算符的使用貫穿始終
    的頭像 發表于 09-18 15:56 ?378次閱讀
    技術干貨驛站 ▏深入理解<b class='flag-5'>C</b><b class='flag-5'>語言</b>:編程高手必備,全方位解析<b class='flag-5'>運算</b>符的核心技能!

    擁有SHA-256核心和32Kbits的EEPROM應用的加密芯片-GEN-FA

    加密芯片 - GEN -FA有32 Kbits的EEPROM。配置數據和用戶數據可以保存在EEPRO m。數據由密碼和加密n保護。GEN有SHA-256核心。SHA-256用于身份驗證。
    的頭像 發表于 09-13 09:36 ?319次閱讀
    擁有<b class='flag-5'>SHA</b>-256核心和32Kbits的EEPROM應用的加密芯片-GEN-FA

    TMP1827 具有 SHA-256-HMAC 認證引擎、2Kb EEPROM 的 1-Wire?、±0.2°C 精度溫度傳感器數據表

    電子發燒友網站提供《TMP1827 具有 SHA-256-HMAC 認證引擎、2Kb EEPROM 的 1-Wire?、±0.2°C 精度溫度傳感器數據表.pdf》資料免費下載
    發表于 08-12 10:20 ?0次下載
    TMP1827 具有 <b class='flag-5'>SHA</b>-256-HMAC 認證引擎、2Kb EEPROM 的 <b class='flag-5'>1</b>-Wire?、±0.2°<b class='flag-5'>C</b> 精度溫度傳感器數據表

    esp32-c3開啟安全啟動和flash加密概率不啟動是什么原因導致的?

    esp32-c3開啟安全啟動和flash加密概率不啟動,重新上電就好了,啟動時候簽名校驗錯誤,硬件sha256 返回全0,懷疑是燒efuse影響了硬件sha,把硬件
    發表于 06-19 06:42

    ESP32-C3下載后提示SHA256校驗失敗的原因?

    ) cpu_start: Starting scheduler. ESP-ROM:esp32c3-api1-20210207 Build:Feb7 2021 rst:0x7 (TG0WDT_SYS_RST),boot
    發表于 06-19 06:01

    ESP-IDF 5.0.1啟動時提示“SHA-256 comparison failed:”是什么問題?

    :0xee mode:DIO, clock div:1 load:0x3fce3810,len:0x164c load:0x403c9700,len:0xbe0 load:0x403cc700,len
    發表于 06-11 06:20

    esp32如何先將OAT下來的固件進行sha256或者MD5校驗,再寫入相應的flash區域?

    esp32如何先將OAT下來的固件進行sha256或者MD5校驗,再寫入相應的flash區域,OAT下來的固件先放在哪里?
    發表于 06-07 07:53

    《深入理解FFmpeg閱讀體驗》

    (SYSV), dynamically linked, BuildID[sha1]=01dd733d65c98eb894b4cdd41216259543ec8405, with debug_info
    發表于 04-16 22:54

    【米爾-芯馳D9360商顯板試用評測】FFmpeg移植

    , for GNU/Linux 3.7.0, BuildID[sha1]=5d3fa4ea21ad6c4395bbaf134b915190799305b2, stripped
    發表于 04-16 22:48

    C語言支持的算術運算符介紹

    先賦值后運算:Line 1 - c 的值是 10Line 2 - a 的值是 11Line 3 - c 的值是 10Line 4 - a 的值是 9先
    發表于 03-13 12:24 ?503次閱讀
    <b class='flag-5'>C</b><b class='flag-5'>語言</b>支持的算術<b class='flag-5'>運算</b>符介紹

    CRYPTO SHA256和CRC不起作用,總是返回0的原因?

    flash area calc sha256 hash flash_offset = CY_DFU_APP1_VERIFY_START; while (flash_offset <
    發表于 01-30 07:04
    主站蜘蛛池模板: 五月丁香| 午夜影视体验区| 亚洲成人免费网站| 天天干天天狠| 国产成年网站v片在线观看| 深爱开心激情网| 国产综合视频在线观看| 91激情在线| 国产又色又爽又黄的网站在线一级| 色婷婷亚洲精品综合影院| 这里只有精品在线| 欧美在线不卡视频| 二级特黄绝大片免费视频大片| 午夜影院免费版| 手机在线看a| 天天做天天爱夜夜爽女人爽宅| 国产精品资源站| 黄色生活毛片| 免费看成年视频网页| 三级网站免费看| 特级淫片aaaaa片毛片| 在线观看网址你懂得| 四虎影视在线看| 四虎永久在线观看免费网站网址 | 天天插天天操天天射| 国内久久精品| 亚洲成a人一区二区三区| 一色屋成人免费精品网| 中文字幕在线第一页| 热99视频| 午夜爱爱爱爱爽爽爽网站免费| 在线观看免费视频国产| 性欧美黑人巨大videos| 婷婷99| 午夜性福利| 美女免费视频色在线观看| 免费高清一级欧美片在线观看| 丁香花小说| 午夜视频在线观看国产www| 秋霞麻豆| 国产女同|