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

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

概述

大家都知道摘要算法在安全領域，也是一個特別重要的存在，而SHA384是其中比較常見的一種摘要算法，它的特點就是計算復雜度較低，不等長的數據原文輸入，可以得出等長的摘要值，這個值是固定為48字節。正是由于這種特殊性，很多重要的數據完整性校驗領域，都可以看到SHAxxx的影子。從復雜度上看，它是復雜于SHA256的，但是又比SHA512低一些，所以它的位置相對較尷尬，真正使用的場景比較少。
今天給大家帶來SHA384的C源碼版本實現，值得注意的是，SHA384與SHA512是公用一套核心源碼實現，只不過在上下文中有一個is_384的變量，標識是執行SHA384運算還是SHA512運算，這一點所以需要結合SHA512那篇文章一起看。歡迎大家深入學習和討論。

頭文件定義

頭文件定義如下，主要定義了SHA384的上下文結構體，，以及導出的三個API，其實它是復用了SHA512的上下文定義，具體請看SHA512：

#ifndef __SHA384_H__
#define __SHA384_H__

#include 

#include "sha512.h"

typedef sha512_ctx_t sha384_ctx_t;

#define SHA384_DIGEST_LEN 48         	// SHA384 outputs a 48 byte digest

void crypto_sha384_init(sha384_ctx_t *ctx);
void crypto_sha384_update(sha384_ctx_t *ctx, const uint8_t *data, uint32_t len);
void crypto_sha384_final(sha384_ctx_t *ctx, uint8_t *digest);

#endif   // __SHA384_H__

C語言版本的實現源碼

下面是SHA384的C語言版本實現，實則是根據SHA512的上下文定義及其核心實現代碼封裝而來的，主要也是圍繞導出的3個API：

#include 
#include "sha384.h"

extern void crypto_sha384_sha512_init(sha512_ctx_t *ctx, int is_384);

/*
 * SHA-384 process init
 */
void crypto_sha384_init( sha512_ctx_t *ctx )
{
	crypto_sha384_sha512_init(ctx, 1);
}

/*
 * SHA-384 process buffer
 */
void crypto_sha384_update( sha512_ctx_t *ctx,
                               const uint8_t *data,
                               uint32_t len )
{
    crypto_sha512_update(ctx, data, len);
}

/*
 * SHA-384 final digest
 */
void crypto_sha384_final( sha512_ctx_t *ctx,
                               uint8_t *digest )
{
    crypto_sha512_final(ctx, digest);
}

測試用例

針對SHA384導出的三個接口，我編寫了以下測試用例：

#include 
#include 

#include "sha384.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 = "6737FF230509CCF14036A06CED588722999F1E979B42EDE982D5C769F34DAFEB4357D71D7774275F5D20419FB2267B99";
	uint8_t digest_calc[SHA384_DIGEST_LEN];
    uint8_t digest_exp_hex[SHA384_DIGEST_LEN];
	sha384_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_sha384_init(&ctx);
	crypto_sha384_update(&ctx, (uint8_t *)p_calc, strlen(p_calc));
	crypto_sha384_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("SHA384 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("SHA384 digest test FAIL\n");
	}

	return 0;
}

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

github倉庫

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

更多參考鏈接

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

審核編輯：湯梓紅