C 应用哈希函数n次_C_Hash - Fatal编程技术网

C 应用哈希函数n次

c hash

C 应用哈希函数n次,c,hash,C,Hash,我需要高效地实现特定哈希函数的迭代应用，例如输入xn次的SHA1，即SHA1（…SHA1（x）））。我正试图用下面的代码来实现这一点，但是这对于n=2^16来说是如此缓慢的2秒。在下面的代码中，$n$是应用SHA1、x=seedj1和temp=SHA1（…SHA1（x））的次数。你能帮我吗 int hashcwe_n1(int n, unsigned char * seedj1, unsigned char * temp) { int i, j; int r = 160; memcpy(temp

我需要高效地实现特定哈希函数的迭代应用，例如输入xn次的SHA1，即SHA1（…SHA1（x）））。我正试图用下面的代码来实现这一点，但是这对于n=2^16来说是如此缓慢的2秒。在下面的代码中，$n$是应用SHA1、x=seedj1和temp=SHA1（…SHA1（x））的次数。你能帮我吗

int hashcwe_n1(int n, unsigned char * seedj1, unsigned char * temp) {
int i, j;
int r = 160;
memcpy(temp, seedj1, r);
for (i = 0; i < n; i++) {
    SHA1(seedj1, r, temp);
    if (n % 2 != 0)
        swapStrings(&temp, &seedj1);
    else {
        if (i == n - 1) {
            memcpy(seedj1, R, r);
        } else {
         swapStrings(&temp, &seedj1);
        }
    }
}
return 1;
}

void swapStrings(unsigned char** a, unsigned char** b) {
unsigned char *temp = *a;
*a = *b;
*b = temp;
}

int hashcwe_n1（int n，无符号字符*seedj1，无符号字符*temp）{
int i，j；
int r=160；
memcpy（温度、种子J1、r）；
对于（i=0；i

我甚至不相信你的算法是正确的，所以衡量它的性能在某种程度上类似于在母鸡下蛋之前数鸡，更不用说在蛋孵化之前了

迭代工作负载函数没有理由表现出如此糟糕的性能，除非

您的SHA实现效率极低
您的测试平台是在Windows 3.11全新且令人兴奋时制作的

以下是一个夹具，应该是正确的，并表现出可接受的性能（在我看来，至少）。所用试验机的相关数据：

MacBook Air（2011），Intel Core i7 Duo，4GB 1333mhz内存
苹果LLVM版本6.1.0（clang-602.0.53）（基于LLVM 3.6.0svn）
OpenSSL libcrypto版本0.9.8zd 2015年1月8日

来源

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <openssl/sha.h>

// simple hex-print utility
void hex_print(const void *buf, size_t n)
{
    const unsigned char *beg = buf, *end = beg+n;
    while (beg != end)
        printf("%02x", *beg++);
    fputc('\n', stdout);
}


// iterate n-times
void hashcwe_n
(
    unsigned short n,   // iteration count
    void *src,          // source bytes
    size_t slen,        // souce length
    void *dst           // target buffer
)
{
    unsigned char md1[SHA_DIGEST_LENGTH];
    unsigned char md2[SHA_DIGEST_LENGTH];
    unsigned char *p1 = md1, *p2 = md2;
    unsigned short i;

    if (n == 0)
        return;

    // perform initial digest
    SHA1(src, slen, md1);

    // iterate the remainder of the loop
    for (i=0; i<(n-1); ++i)
    {
        unsigned char *tmp = p1;
        SHA1(p1, SHA_DIGEST_LENGTH, p2);
        p1 = p2;
        p2 = tmp;
    }
    memcpy(dst, p1, SHA_DIGEST_LENGTH);
}

// main entry point
int main()
{
    unsigned char data[] = {0x61,0x62,0x63}; // "abc"
    unsigned char md[SHA_DIGEST_LENGTH] = {0};

    hashcwe_n(USHRT_MAX, data, sizeof(data), md);
    hex_print(md, SHA_DIGEST_LENGTH);

    return 0;
}

$ time ./sample
a21b4b42e20066a1046d3c81b42b7cd8a6403bf2

real  0m0.031s
user  0m0.026s
sys   0m0.003s

输出控制台

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <openssl/sha.h>

// simple hex-print utility
void hex_print(const void *buf, size_t n)
{
    const unsigned char *beg = buf, *end = beg+n;
    while (beg != end)
        printf("%02x", *beg++);
    fputc('\n', stdout);
}


// iterate n-times
void hashcwe_n
(
    unsigned short n,   // iteration count
    void *src,          // source bytes
    size_t slen,        // souce length
    void *dst           // target buffer
)
{
    unsigned char md1[SHA_DIGEST_LENGTH];
    unsigned char md2[SHA_DIGEST_LENGTH];
    unsigned char *p1 = md1, *p2 = md2;
    unsigned short i;

    if (n == 0)
        return;

    // perform initial digest
    SHA1(src, slen, md1);

    // iterate the remainder of the loop
    for (i=0; i<(n-1); ++i)
    {
        unsigned char *tmp = p1;
        SHA1(p1, SHA_DIGEST_LENGTH, p2);
        p1 = p2;
        p2 = tmp;
    }
    memcpy(dst, p1, SHA_DIGEST_LENGTH);
}

// main entry point
int main()
{
    unsigned char data[] = {0x61,0x62,0x63}; // "abc"
    unsigned char md[SHA_DIGEST_LENGTH] = {0};

    hashcwe_n(USHRT_MAX, data, sizeof(data), md);
    hex_print(md, SHA_DIGEST_LENGTH);

    return 0;
}

$ time ./sample
a21b4b42e20066a1046d3c81b42b7cd8a6403bf2

real  0m0.031s
user  0m0.026s
sys   0m0.003s

对于同一个示例，在Coliru上实时运行

祝你好运

我甚至不相信你的算法是正确的，因此衡量它的性能在某种程度上类似于在母鸡下蛋之前数鸡，更不用说在蛋孵化之前了

迭代工作负载函数没有理由表现出如此糟糕的性能，除非

您的SHA实现效率极低
您的测试平台是在Windows 3.11全新且令人兴奋时制作的

以下是一个夹具，应该是正确的，并表现出可接受的性能（在我看来，至少）。所用试验机的相关数据：

MacBook Air（2011），Intel Core i7 Duo，4GB 1333mhz内存
苹果LLVM版本6.1.0（clang-602.0.53）（基于LLVM 3.6.0svn）
OpenSSL libcrypto版本0.9.8zd 2015年1月8日

来源

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <openssl/sha.h>

// simple hex-print utility
void hex_print(const void *buf, size_t n)
{
    const unsigned char *beg = buf, *end = beg+n;
    while (beg != end)
        printf("%02x", *beg++);
    fputc('\n', stdout);
}


// iterate n-times
void hashcwe_n
(
    unsigned short n,   // iteration count
    void *src,          // source bytes
    size_t slen,        // souce length
    void *dst           // target buffer
)
{
    unsigned char md1[SHA_DIGEST_LENGTH];
    unsigned char md2[SHA_DIGEST_LENGTH];
    unsigned char *p1 = md1, *p2 = md2;
    unsigned short i;

    if (n == 0)
        return;

    // perform initial digest
    SHA1(src, slen, md1);

    // iterate the remainder of the loop
    for (i=0; i<(n-1); ++i)
    {
        unsigned char *tmp = p1;
        SHA1(p1, SHA_DIGEST_LENGTH, p2);
        p1 = p2;
        p2 = tmp;
    }
    memcpy(dst, p1, SHA_DIGEST_LENGTH);
}

// main entry point
int main()
{
    unsigned char data[] = {0x61,0x62,0x63}; // "abc"
    unsigned char md[SHA_DIGEST_LENGTH] = {0};

    hashcwe_n(USHRT_MAX, data, sizeof(data), md);
    hex_print(md, SHA_DIGEST_LENGTH);

    return 0;
}

$ time ./sample
a21b4b42e20066a1046d3c81b42b7cd8a6403bf2

real  0m0.031s
user  0m0.026s
sys   0m0.003s

输出控制台

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <openssl/sha.h>

// simple hex-print utility
void hex_print(const void *buf, size_t n)
{
    const unsigned char *beg = buf, *end = beg+n;
    while (beg != end)
        printf("%02x", *beg++);
    fputc('\n', stdout);
}


// iterate n-times
void hashcwe_n
(
    unsigned short n,   // iteration count
    void *src,          // source bytes
    size_t slen,        // souce length
    void *dst           // target buffer
)
{
    unsigned char md1[SHA_DIGEST_LENGTH];
    unsigned char md2[SHA_DIGEST_LENGTH];
    unsigned char *p1 = md1, *p2 = md2;
    unsigned short i;

    if (n == 0)
        return;

    // perform initial digest
    SHA1(src, slen, md1);

    // iterate the remainder of the loop
    for (i=0; i<(n-1); ++i)
    {
        unsigned char *tmp = p1;
        SHA1(p1, SHA_DIGEST_LENGTH, p2);
        p1 = p2;
        p2 = tmp;
    }
    memcpy(dst, p1, SHA_DIGEST_LENGTH);
}

// main entry point
int main()
{
    unsigned char data[] = {0x61,0x62,0x63}; // "abc"
    unsigned char md[SHA_DIGEST_LENGTH] = {0};

    hashcwe_n(USHRT_MAX, data, sizeof(data), md);
    hex_print(md, SHA_DIGEST_LENGTH);

    return 0;
}

$ time ./sample
a21b4b42e20066a1046d3c81b42b7cd8a6403bf2

real  0m0.031s
user  0m0.026s
sys   0m0.003s

对于同一个示例，在Coliru上实时运行

祝你好运

我甚至不相信你的算法是正确的，因此衡量它的性能在某种程度上类似于在母鸡下蛋之前数鸡，更不用说在蛋孵化之前了

迭代工作负载函数没有理由表现出如此糟糕的性能，除非

您的SHA实现效率极低
您的测试平台是在Windows 3.11全新且令人兴奋时制作的

以下是一个夹具，应该是正确的，并表现出可接受的性能（在我看来，至少）。所用试验机的相关数据：

MacBook Air（2011），Intel Core i7 Duo，4GB 1333mhz内存
苹果LLVM版本6.1.0（clang-602.0.53）（基于LLVM 3.6.0svn）
OpenSSL libcrypto版本0.9.8zd 2015年1月8日

来源

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <openssl/sha.h>

// simple hex-print utility
void hex_print(const void *buf, size_t n)
{
    const unsigned char *beg = buf, *end = beg+n;
    while (beg != end)
        printf("%02x", *beg++);
    fputc('\n', stdout);
}


// iterate n-times
void hashcwe_n
(
    unsigned short n,   // iteration count
    void *src,          // source bytes
    size_t slen,        // souce length
    void *dst           // target buffer
)
{
    unsigned char md1[SHA_DIGEST_LENGTH];
    unsigned char md2[SHA_DIGEST_LENGTH];
    unsigned char *p1 = md1, *p2 = md2;
    unsigned short i;

    if (n == 0)
        return;

    // perform initial digest
    SHA1(src, slen, md1);

    // iterate the remainder of the loop
    for (i=0; i<(n-1); ++i)
    {
        unsigned char *tmp = p1;
        SHA1(p1, SHA_DIGEST_LENGTH, p2);
        p1 = p2;
        p2 = tmp;
    }
    memcpy(dst, p1, SHA_DIGEST_LENGTH);
}

// main entry point
int main()
{
    unsigned char data[] = {0x61,0x62,0x63}; // "abc"
    unsigned char md[SHA_DIGEST_LENGTH] = {0};

    hashcwe_n(USHRT_MAX, data, sizeof(data), md);
    hex_print(md, SHA_DIGEST_LENGTH);

    return 0;
}

$ time ./sample
a21b4b42e20066a1046d3c81b42b7cd8a6403bf2

real  0m0.031s
user  0m0.026s
sys   0m0.003s

输出控制台

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <openssl/sha.h>

// simple hex-print utility
void hex_print(const void *buf, size_t n)
{
    const unsigned char *beg = buf, *end = beg+n;
    while (beg != end)
        printf("%02x", *beg++);
    fputc('\n', stdout);
}


// iterate n-times
void hashcwe_n
(
    unsigned short n,   // iteration count
    void *src,          // source bytes
    size_t slen,        // souce length
    void *dst           // target buffer
)
{
    unsigned char md1[SHA_DIGEST_LENGTH];
    unsigned char md2[SHA_DIGEST_LENGTH];
    unsigned char *p1 = md1, *p2 = md2;
    unsigned short i;

    if (n == 0)
        return;

    // perform initial digest
    SHA1(src, slen, md1);

    // iterate the remainder of the loop
    for (i=0; i<(n-1); ++i)
    {
        unsigned char *tmp = p1;
        SHA1(p1, SHA_DIGEST_LENGTH, p2);
        p1 = p2;
        p2 = tmp;
    }
    memcpy(dst, p1, SHA_DIGEST_LENGTH);
}

// main entry point
int main()
{
    unsigned char data[] = {0x61,0x62,0x63}; // "abc"
    unsigned char md[SHA_DIGEST_LENGTH] = {0};

    hashcwe_n(USHRT_MAX, data, sizeof(data), md);
    hex_print(md, SHA_DIGEST_LENGTH);

    return 0;
}

$ time ./sample
a21b4b42e20066a1046d3c81b42b7cd8a6403bf2

real  0m0.031s
user  0m0.026s
sys   0m0.003s

对于同一个示例，在Coliru上实时运行

祝你好运

我甚至不相信你的算法是正确的，因此衡量它的性能在某种程度上类似于在母鸡下蛋之前数鸡，更不用说在蛋孵化之前了

迭代工作负载函数没有理由表现出如此糟糕的性能，除非

您的SHA实现效率极低
您的测试平台是在Windows 3.11全新且令人兴奋时制作的

以下是一个夹具，应该是正确的，并表现出可接受的性能（在我看来，至少）。所用试验机的相关数据：

MacBook Air（2011），Intel Core i7 Duo，4GB 1333mhz内存
苹果LLVM版本6.1.0（clang-602.0.53）（基于LLVM 3.6.0svn）
OpenSSL libcrypto版本0.9.8zd 2015年1月8日

来源

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <openssl/sha.h>

// simple hex-print utility
void hex_print(const void *buf, size_t n)
{
    const unsigned char *beg = buf, *end = beg+n;
    while (beg != end)
        printf("%02x", *beg++);
    fputc('\n', stdout);
}


// iterate n-times
void hashcwe_n
(
    unsigned short n,   // iteration count
    void *src,          // source bytes
    size_t slen,        // souce length
    void *dst           // target buffer
)
{
    unsigned char md1[SHA_DIGEST_LENGTH];
    unsigned char md2[SHA_DIGEST_LENGTH];
    unsigned char *p1 = md1, *p2 = md2;
    unsigned short i;

    if (n == 0)
        return;

    // perform initial digest
    SHA1(src, slen, md1);

    // iterate the remainder of the loop
    for (i=0; i<(n-1); ++i)
    {
        unsigned char *tmp = p1;
        SHA1(p1, SHA_DIGEST_LENGTH, p2);
        p1 = p2;
        p2 = tmp;
    }
    memcpy(dst, p1, SHA_DIGEST_LENGTH);
}

// main entry point
int main()
{
    unsigned char data[] = {0x61,0x62,0x63}; // "abc"
    unsigned char md[SHA_DIGEST_LENGTH] = {0};

    hashcwe_n(USHRT_MAX, data, sizeof(data), md);
    hex_print(md, SHA_DIGEST_LENGTH);

    return 0;
}

$ time ./sample
a21b4b42e20066a1046d3c81b42b7cd8a6403bf2

real  0m0.031s
user  0m0.026s
sys   0m0.003s

输出控制台

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <openssl/sha.h>

// simple hex-print utility
void hex_print(const void *buf, size_t n)
{
    const unsigned char *beg = buf, *end = beg+n;
    while (beg != end)
        printf("%02x", *beg++);
    fputc('\n', stdout);
}


// iterate n-times
void hashcwe_n
(
    unsigned short n,   // iteration count
    void *src,          // source bytes
    size_t slen,        // souce length
    void *dst           // target buffer
)
{
    unsigned char md1[SHA_DIGEST_LENGTH];
    unsigned char md2[SHA_DIGEST_LENGTH];
    unsigned char *p1 = md1, *p2 = md2;
    unsigned short i;

    if (n == 0)
        return;

    // perform initial digest
    SHA1(src, slen, md1);

    // iterate the remainder of the loop
    for (i=0; i<(n-1); ++i)
    {
        unsigned char *tmp = p1;
        SHA1(p1, SHA_DIGEST_LENGTH, p2);
        p1 = p2;
        p2 = tmp;
    }
    memcpy(dst, p1, SHA_DIGEST_LENGTH);
}

// main entry point
int main()
{
    unsigned char data[] = {0x61,0x62,0x63}; // "abc"
    unsigned char md[SHA_DIGEST_LENGTH] = {0};

    hashcwe_n(USHRT_MAX, data, sizeof(data), md);
    hex_print(md, SHA_DIGEST_LENGTH);

    return 0;
}

$ time ./sample
a21b4b42e20066a1046d3c81b42b7cd8a6403bf2

real  0m0.031s
user  0m0.026s
sys   0m0.003s

对于同一个示例，在Coliru上实时运行

祝你好运

抛开优化不谈，你的代码看起来有点可疑。SHA1产生160位，但数组的长度似乎是160字节。另外，您正在将

复制到末尾的

种子j1

，但此代码中没有

。它运行是否正确？swapString（）只会更改hashcwe_n1（）函数参数列表中指针副本中的指针（在C中通过值传递）。撇开优化不谈，您的代码似乎有点错误。SHA1产生160位，但数组的长度似乎是160字节。另外，您正在将

复制到末尾的

种子j1

，但此代码中没有

复制到末尾的

种子j1

，但此代码中没有

。它运行是否正确？swapString（）只更改hashcwe_n1（）函数参数列表中指针副本中的指针（在C中通过值传递）