版权归作者所有,如有转发,请注明文章出处:https://cyrus-studio.github.io/blog/

标准 SHA1

SHA1(Secure Hash Algorithm 1)是一种广泛使用的 加密哈希函数,用于生成固定长度的 160 位(20 字节)哈希值。它由 美国国家安全局(NSA) 设计,并由 NIST(美国国家标准与技术研究院) 在 1995 年作为 FIPS PUB 180-1 标准发布。

SHA1 的基本特点

  • 输出长度:160 位(20 字节)的哈希值,通常以长度为 40 的 hex 字符串表示

  • 使用 5 个固定的初始哈希值(MD5 是 4 个)

  • 不可逆性:无法从哈希值反推出原文

  • 固定性:相同的输入始终会产生相同的输出

  • 雪崩效应:输入的微小变化会导致输出哈希值的巨大变化

  • 抗碰撞性(已破坏):理论上很难找到两个不同的输入产生相同的哈希值

SHA1 C++ 标准实现如下:

sha1.h

#ifndef SHA1_H
#define SHA1_H
#include <stdlib.h>
#include <string.h>
#include <asm/types.h>

#define os_memcpy   memcpy
#define os_memset   memset
#define os_memcmp   memcmp
#define os_strlen   strlen

#define MAX_SHA1_LEN    32
#define SHA1_MAC_LEN    20

typedef __u8 u8;
typedef __u32 u32;

struct SHA1Context {
    u32 state[5];
    u32 count[2];
    unsigned char buffer[64];
};
typedef struct SHA1Context SHA1_CTX;

void SHA1Init(SHA1_CTX *context);
void SHA1Update(SHA1_CTX *context, const unsigned char *data, u32 len);
void SHA1Final(unsigned char digest[20], SHA1_CTX *context);

#endif /* SHA1_H */

sha1.cpp

#include "sha1.h"

#define SHA1HANDSOFF
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
/* blk0() and blk() perform the initial expand. */
/* I got the idea of expanding during the round function from SSLeay */
#ifndef WORDS_BIGENDIAN
#define blk0(i) (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \
    (rol(block->l[i], 8) & 0x00FF00FF))
#else
#define blk0(i) block->l[i]
#endif
#define blk(i) (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ \
    block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
#define R0(v,w,x,y,z,i) \
    z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
    w = rol(w, 30);
#define R1(v,w,x,y,z,i) \
    z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
    w = rol(w, 30);
#define R2(v,w,x,y,z,i) \
    z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
#define R3(v,w,x,y,z,i) \
    z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
    w = rol(w, 30);
#define R4(v,w,x,y,z,i) \
    z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
    w=rol(w, 30);
#ifdef VERBOSE  /* SAK */
void SHAPrintContext(SHA1_CTX *context, char *msg)
{
    printf("%s (%d,%d) %x %x %x %x %x\n",
           msg,
           context->count[0], context->count[1], 
           context->state[0],
           context->state[1],
           context->state[2],
           context->state[3],
           context->state[4]);
}
#endif
/* Hash a single 512-bit block. This is the core of the algorithm. */
static void SHA1Transform(u32 state[5], const unsigned char buffer[64])
{
    u32 a, b, c, d, e;
    typedef union {
       unsigned char c[64];
       u32 l[16];
    } CHAR64LONG16;
    CHAR64LONG16* block;
#ifdef SHA1HANDSOFF
    CHAR64LONG16 workspace;
    block = &workspace;
    os_memcpy(block, buffer, 64);
#else
    block = (CHAR64LONG16 *) buffer;
#endif
    /* Copy context->state[] to working vars */
    a = state[0];
    b = state[1];
    c = state[2];
    d = state[3];
    e = state[4];
    /* 4 rounds of 20 operations each. Loop unrolled. */
    R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
    R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
    R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
    R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
    R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
    R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
    R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
    R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
    R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
    R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
    R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
    R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
    R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
    R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
    R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
    R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
    R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
    R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
    R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
    R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
    /* Add the working vars back into context.state[] */
    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;
    state[4] += e;
    /* Wipe variables */
    a = b = c = d = e = 0;
#ifdef SHA1HANDSOFF
    os_memset(block, 0, 64);
#endif
}


/* SHA1Init - Initialize new context */
void SHA1Init(SHA1_CTX* context)
{
    /* SHA1 initialization constants */
    context->state[0] = 0x67452301;
    context->state[1] = 0xEFCDAB89;
    context->state[2] = 0x98BADCFE;
    context->state[3] = 0x10325476;
    context->state[4] = 0xC3D2E1F0;
    context->count[0] = context->count[1] = 0;
}
/* Run your data through this. */
void SHA1Update(SHA1_CTX* context, const unsigned char *_data, u32 len)
{
    u32 i, j;
    const unsigned char *data = _data;
#ifdef VERBOSE
    SHAPrintContext(context, "before");
#endif
    j = (context->count[0] >> 3) & 63;
    if ((context->count[0] += len << 3) < (len << 3))
       context->count[1]++;
    context->count[1] += (len >> 29);
    if ((j + len) > 63) {
       os_memcpy(&context->buffer[j], data, (i = 64-j));
       SHA1Transform(context->state, context->buffer);
       for ( ; i + 63 < len; i += 64) {
          SHA1Transform(context->state, &data[i]);
       }
       j = 0;
    }
    else i = 0;
    os_memcpy(&context->buffer[j], &data[i], len - i);
#ifdef VERBOSE
    SHAPrintContext(context, "after ");
#endif
}
/* Add padding and return the message digest. */
void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
{
    u32 i;
    unsigned char finalcount[8];
    for (i = 0; i < 8; i++) {
       finalcount[i] = (unsigned char)
          ((context->count[(i >= 4 ? 0 : 1)] >>
            ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
    }
    SHA1Update(context, (unsigned char *) "\200", 1);
    while ((context->count[0] & 504) != 448) {
       SHA1Update(context, (unsigned char *) "\0", 1);
    }
    SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform()
                      */
    for (i = 0; i < 20; i++) {
       digest[i] = (unsigned char)
          ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) &
           255);
    }
    /* Wipe variables */
    i = 0;
    os_memset(context->buffer, 0, 64);
    os_memset(context->state, 0, 20);
    os_memset(context->count, 0, 8);
    os_memset(finalcount, 0, 8);
}

参考:

kotlin 层声明 native 方法 sha1

package com.cyrus.example.sha1

import android.R
import java.security.MessageDigest


class SHA1Utils {

    companion object {
        // 加载 native 库
        init {
            System.loadLibrary("sha1")
        }

        // 声明 native 静态方法
        @JvmStatic
        external fun sha1(input: String): String
    }
}

实现 sha1 方法

#include <jni.h>
#include <string>
#include "sha1.h"

// 将字节数组转换为十六进制字符串
std::string bytesToHex(const unsigned char* bytes, size_t length) {
    std::string hex;
    const char hexDigits[] = "0123456789abcdef";
    for (size_t i = 0; i < length; i++) {
        hex += hexDigits[(bytes[i] >> 4) & 0x0F];
        hex += hexDigits[bytes[i] & 0x0F];
    }
    return hex;
}


// JNI 方法实现
extern "C" JNIEXPORT jstring JNICALL
Java_com_cyrus_example_sha1_SHA1Utils_sha1(JNIEnv* env, jclass clazz, jstring input) {
    const char* inputStr = env->GetStringUTFChars(input, nullptr);
    if (!inputStr) {
        return nullptr; // 内存分配失败
    }

    // 初始化 SHA1 上下文
    SHA1_CTX ctx;
    unsigned char digest[SHA1_MAC_LEN];

    SHA1Init(&ctx);
    SHA1Update(&ctx, (const unsigned char*)inputStr, (u32)strlen(inputStr));
    SHA1Final(digest, &ctx);

    env->ReleaseStringUTFChars(input, inputStr);

    // 转换为 hex 字符串
    std::string hexResult = bytesToHex(digest, SHA1_MAC_LEN);

    // 返回结果
    return env->NewStringUTF(hexResult.c_str());
}

和 MD5 算法类似,SHA1 也有 Init、 Update 、Final 函数。

效果如下:

word/media/image1.png

SHA1Init

SHA1Init 是 SHA1 算法中的一个初始化函数,用于初始化 SHA1 的上下文 (SHA1_CTX),设置初始状态和计数器,为后续的哈希计算做好准备。

我们可以修改 5 个固定的初始哈希值来实现 SHA1 算法变形,比如:

void SHA1Init(SHA1_CTX* context)
{
    /* SHA1 initialization constants */
    context->state[0] = 0xAA452301;
    context->state[1] = 0xBBCDAB89;
    context->state[2] = 0xCCBADCFE;
    context->state[3] = 0xDD325476;
    context->state[4] = 0xEED2E1F0;
    context->count[0] = context->count[1] = 0;
}

效果如下:

word/media/image2.png

SHA1Update

SHA1Update 用于处理输入数据。它会将数据划分为 512 位(64 字节)的块,并对每个块执行一次 SHA1Transform 运算,同时更新哈希状态。

我们可以通过调用 SHA1Update 去拼接自定义的字符串实现 SHA1 算法变形,比如:

const char* inputStr = env->GetStringUTFChars(input, nullptr);
if (!inputStr) {
    return nullptr; // 内存分配失败
}

// 初始化 SHA1 上下文
SHA1_CTX ctx;
unsigned char digest[SHA1_MAC_LEN];

SHA1Init(&ctx);
SHA1Update(&ctx, (const unsigned char*)"cyrus", (u32)strlen(inputStr));
SHA1Update(&ctx, (const unsigned char*)inputStr, (u32)strlen(inputStr));
SHA1Update(&ctx, (const unsigned char*)"studio", (u32)strlen(inputStr));
SHA1Final(digest, &ctx);

env->ReleaseStringUTFChars(input, inputStr);

// 转换为 hex 字符串
std::string hexResult = bytesToHex(digest, SHA1_MAC_LEN);

// 返回结果
return env->NewStringUTF(hexResult.c_str());

效果如下:

word/media/image3.png

宏 R0, R1, R2, R3, R4

在 SHA1 算法中,R0、R1、R2、R3、R4 是 SHA1 的五个主要轮次(Rounds),每个轮次包含 20 次操作,总共 80 次迭代。

这些轮次的核心是基于位运算的消息调度和非线性函数的应用,用于将输入数据混淆并生成最终的哈希值。

轮次简介:

  • R0 (Round 0):初始阶段,对输入数据进行简单的消息扩展。

  • R1 (Round 1):进一步扩展数据,使用简单的逻辑运算。

  • R2 (Round 2):采用异或运算进行复杂的混淆。

  • R3 (Round 3):使用更多的位运算,引入更多的非线性。

  • R4 (Round 4):最终的轮次,进一步强化数据的不可逆性。

我们可以通过修改宏中的常量实现 SHA1 算法变形,比如:

/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
#define R0(v,w,x,y,z,i) \
    z += ((w & (x ^ y)) ^ y) + blk0(i) + 0xAA827999 + rol(v, 5); \
    w = rol(w, 30);
#define R1(v,w,x,y,z,i) \
    z += ((w & (x ^ y)) ^ y) + blk(i) + 0xBB827999 + rol(v, 5); \
    w = rol(w, 30);
#define R2(v,w,x,y,z,i) \
    z += (w ^ x ^ y) + blk(i) + 0xCCD9EBA1 + rol(v, 5); w = rol(w, 30);
#define R3(v,w,x,y,z,i) \
    z += (((w | x) & y) | (w & x)) + blk(i) + 0xDD1BBCDC + rol(v, 5); \
    w = rol(w, 30);
#define R4(v,w,x,y,z,i) \
    z += (w ^ x ^ y) + blk(i) + 0xEE62C1D6 + rol(v, 5); \
    w=rol(w, 30);

效果如下:

word/media/image4.png

完整源码

完整源码地址:https://github.com/CYRUS-STUDIO/AndroidExample