【安全算法之SHA384】SHA384摘要运算的C语言源码实现

概述

大家都知道摘要算法在安全领域，也是一个特别重要的存在，而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] 【安全算法之概述】一文带你简要了解常见常用的安全算法
[3] 【安全算法之base64】base64加解密的C语言源码实现
[4] 【安全算法之MD5】MD5摘要运算的C语言源码实现
[5] 【安全算法之SHA1】SHA1摘要运算的C语言源码实现
[6] 【安全算法之SHA224】SHA224摘要运算的C语言源码实现
[7] 【安全算法之SHA256】SHA256摘要运算的C语言源码实现
[8] 【安全算法之SHA384】SHA384摘要运算的C语言源码实现
[9] 【安全算法之SHA512】SHA512摘要运算的C语言源码实现