sha1(代码片段)

sha1算法请参考wiki:  sha1 algorithm

#ifndef _DEFINE_SHA1_H_
#define _DEFINE_SHA1_H_
#ifndef _STRING_H_
#define _STRING_H_
#include<string>
#endif
class SHA1{
    public:
        typedef unsigned int uint32_t;
    private:
        //msgdgt(message digest, 160bit, 20Byte, 5 int)
        uint32_t* _msgdgt;
        //5 constant 
        uint32_t* _k;
    public:
        SHA1();
        ~SHA1();
        std::string getSHA1(std::string data);
    private:
        uint32_t   transform(uint32_t value);
        uint32_t*  preProcess(std::string data);
        void handleBlock(uint32_t* block);
        void reset();
    protected:
        virtual unsigned int step1(uint32_t b, uint32_t c, uint32_t d);
        virtual unsigned int step2(uint32_t b, uint32_t c, uint32_t d);
        virtual unsigned int step3(uint32_t b, uint32_t c, uint32_t d);
        virtual unsigned int step4(uint32_t b, uint32_t c, uint32_t d);
        virtual unsigned int leftRotate(uint32_t value,uint32_t n); 
}; 
#endif

#include "sha1.h"
SHA1::SHA1():_msgdgt(NULL), _k(NULL){}
SHA1::~SHA1(){
    if(_msgdgt) delete[]_msgdgt;
    if(_k) delete[] _k;
}
unsigned int* SHA1::preProcess(std::string data){
   uint32_t  _block_num_ = (data.length() + 8)/64 + 1; 
   uint32_t* _block_ = new uint32_t[_block_num_*16]; 
   uint32_t i = 0;
   for(i = 0; i < _block_num_*16; ++i)
       _block_[i] = 0x00000000;
   for(i = 0; i < data.length(); ++i){
       _block_[i >> 2] |=  ((uint32_t)data[i]) << ((i%4) * 8); 
   } 
   _block_[i >> 2] |= 0x80 << ((i%4)*8);
   _block_[_block_num_*16-2] = data.length()*8;
   uint32_t _low = _block_[_block_num_*16-2]; 
   uint32_t _high = _block_[_block_num_*16-1];
   _low = transform(_low);
   _high = transform(_high);
   _block_[_block_num_*16-2] = _high;
   _block_[_block_num_*16-1] = _low;
   return _block_;
}
void SHA1::handleBlock(uint32_t* block){
    uint32_t a, b, c, d,e, temp = 0x00000000;
    a = _msgdgt[0];
    b = _msgdgt[1];
    c = _msgdgt[2];
    d = _msgdgt[3];
    e = _msgdgt[4];
    uint32_t* w = new uint32_t[80];
    for(int i = 0; i < 16; ++i)
        w[i] = transform(block[i]);
    for(int i = 16; i < 80; ++i){
       uint32_t t = w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16];
       w[i] = leftRotate(t,1);
    }
    for(int i = 0; i < 80; ++i){
        uint32_t f = 0x00000000;
        uint32_t k = 0x00000000;
        if(i < 20){
           f = step1(b, c, d);
           k = _k[0];
        }else if(i < 40){
           f = step2(b, c, d);
           k = _k[1];
        }else if(i < 60){
           f = step3(b, c, d);
           k = _k[2];
        }else{
           f = step4(b, c, d);
           k = _k[3];
        }
        temp = leftRotate(a,5) + f + e + k + w[i];
        e = d;
        d = c;
        c = leftRotate(b, 30);
        b = a;
        a = temp;
    } 
    _msgdgt[0] = (_msgdgt[0] + a) & 0xFFFFFFFF;
    _msgdgt[1] = (_msgdgt[1] + b) & 0xFFFFFFFF;
    _msgdgt[2] = (_msgdgt[2] + c) & 0xFFFFFFFF;
    _msgdgt[3] = (_msgdgt[3] + d) & 0xFFFFFFFF;
    _msgdgt[4] = (_msgdgt[4] + e) & 0xFFFFFFFF;
}
unsigned int SHA1::transform(uint32_t value){
    uint32_t _temp = 0x00000000;
    _temp |= (value & 0x000000ff) << 24;
    _temp |= (value & 0x0000ff00) << 8;
    _temp |= (value & 0x00ff0000) >> 8;
    _temp |= (value & 0xff000000) >> 24;
    return _temp;
}

unsigned int SHA1::step1(uint32_t b, uint32_t c, uint32_t d){
    return (b & c) | ((~b) & d); 
}
unsigned int SHA1::step2(uint32_t b, uint32_t c, uint32_t d){
    return (b ^ c ^ d);
} 
unsigned int SHA1::step3(uint32_t b, uint32_t c, uint32_t d){
    return (b & c) | (b & d) | (c & d);
}
unsigned int SHA1::step4(uint32_t b, uint32_t c, uint32_t d){
    return (b ^ c ^ d);
}
unsigned int SHA1::leftRotate(uint32_t value, uint32_t n){
    return (value << n) | (value >> (32-n));
}
void SHA1::reset(){
    if(_k == NULL){
        _k = new uint32_t[4];
    } 
    if(_msgdgt == NULL){
        _msgdgt =  new uint32_t[5];
    }
    _k[0] = 0x5A827999;
    _k[1] = 0x6ED9EBA1;
    _k[2] = 0x8F1BBCDC;
    _k[3] = 0xCA62C1D6;
    _msgdgt[0] = 0x67452301;
    _msgdgt[1] = 0xEFCDAB89;
    _msgdgt[2] = 0x98BADCFE; 
    _msgdgt[3] = 0x10325476;
    _msgdgt[4] = 0xC3D2E1F0;
}
std::string SHA1::getSHA1(std::string data){
    reset();    
    uint32_t blockNum = (data.length()+8)/64 + 1;
    uint32_t* blockGroup = preProcess(data);
    uint32_t* block = new uint32_t[16];
    for(uint32_t i = 0; i < blockNum; ++i){
        for(int j = 0; j < 16; ++j){
            block[j] = blockGroup[i*16 + j];
        }
        handleBlock(block);
    }
    delete[] block;
    delete[] blockGroup;
    std::string sha1;
    char charmap[16]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
    for(int i = 0; i < 5; ++i){
       int d1 = (_msgdgt[i] & 0x0000000f);
       int d2 = (_msgdgt[i] & 0x000000f0) >> 4;
       int d3 = (_msgdgt[i] & 0x00000f00) >> 8;
       int d4 = (_msgdgt[i] & 0x0000f000) >> 12;
       int d5 = (_msgdgt[i] & 0x000f0000) >> 16;
       int d6 = (_msgdgt[i] & 0x00f00000) >> 20;
       int d7 = (_msgdgt[i] & 0x0f000000) >> 24;
       int d8 = (_msgdgt[i] & 0xf0000000) >> 28;
       sha1.push_back(charmap[d8]); 
       sha1.push_back(charmap[d7]); 
       sha1.push_back(charmap[d6]); 
       sha1.push_back(charmap[d5]); 
       sha1.push_back(charmap[d4]); 
       sha1.push_back(charmap[d3]); 
       sha1.push_back(charmap[d2]); 
       sha1.push_back(charmap[d1]); 
    }
    return sha1;
}

源代码下载地址： sha1 algorithm