CSHA1 Class Reference

#include <SHA1.h>

List of all members.

Public Types

enum  { REPORT_HEX = 0, REPORT_DIGIT = 1 }

Public Member Functions

 CSHA1 ()
 ~CSHA1 ()
void Reset ()
void Update (UINT_8 *data, UINT_32 len)
bool HashFile (char *szFileName)
void Final ()
void ReportHash (char *szReport, unsigned char uReportType=REPORT_HEX)
void GetHash (UINT_8 *puDest)

Public Attributes

UINT_32 m_state [5]
UINT_32 m_count [2]
UINT_32 __reserved1 [1]
UINT_8 m_buffer [64]
UINT_8 m_digest [20]
UINT_32 __reserved2 [3]

Private Member Functions

void Transform (UINT_32 *state, UINT_8 *buffer)

Private Attributes

UINT_8 m_workspace [64]
SHA1_WORKSPACE_BLOCKm_block


Member Enumeration Documentation

anonymous enum

Enumerator:
REPORT_HEX 
REPORT_DIGIT 
00102     {
00103         REPORT_HEX = 0,
00104         REPORT_DIGIT = 1
00105     };


Constructor & Destructor Documentation

CSHA1::CSHA1 (  ) 

00062 {
00063     m_block = (SHA1_WORKSPACE_BLOCK *)m_workspace;
00064 
00065     Reset();
00066 }

CSHA1::~CSHA1 (  ) 

00069 {
00070     Reset();
00071 }


Member Function Documentation

void CSHA1::Reset (  ) 

00074 {
00075     // SHA1 initialization constants
00076     m_state[0] = 0x67452301;
00077     m_state[1] = 0xEFCDAB89;
00078     m_state[2] = 0x98BADCFE;
00079     m_state[3] = 0x10325476;
00080     m_state[4] = 0xC3D2E1F0;
00081 
00082     m_count[0] = 0;
00083     m_count[1] = 0;
00084 }

void CSHA1::Update ( UINT_8 *  data,
UINT_32  len 
)

00191 {
00192     UINT_32 i, j;
00193 
00194     j = (m_count[0] >> 3) & 63;
00195 
00196     if((m_count[0] += len << 3) < (len << 3))
00197         m_count[1]++;
00198 
00199     m_count[1] += (len >> 29);
00200 
00201     if((j + len) > 63) {
00202         i = 64 - j;
00203         memcpy(&m_buffer[j], data, i);
00204         Transform(m_state, m_buffer);
00205 
00206         for( ; i + 63 < len; i += 64)
00207             Transform(m_state, &data[i]);
00208 
00209         j = 0;
00210     } else
00211         i = 0;
00212 
00213     memcpy(&m_buffer[j], &data[i], len - i);
00214 }

bool CSHA1::HashFile ( char *  szFileName  ) 

00219 {
00220     unsigned long ulFileSize, ulRest, ulBlocks;
00221     unsigned long i;
00222     UINT_8 uData[SHA1_MAX_FILE_BUFFER];
00223     FILE *fIn;
00224 
00225     if(szFileName == NULL)
00226         return false;
00227 
00228     fIn = fopen(szFileName, "rb");
00229     if(fIn == NULL)
00230         return false;
00231 
00232     fseek(fIn, 0, SEEK_END);
00233     ulFileSize = (unsigned long)ftell(fIn);
00234     fseek(fIn, 0, SEEK_SET);
00235 
00236     if(ulFileSize != 0) {
00237         ulBlocks = ulFileSize / SHA1_MAX_FILE_BUFFER;
00238         ulRest = ulFileSize % SHA1_MAX_FILE_BUFFER;
00239     } else {
00240         ulBlocks = 0;
00241         ulRest = 0;
00242     }
00243 
00244     for(i = 0; i < ulBlocks; i++) {
00245         fread(uData, 1, SHA1_MAX_FILE_BUFFER, fIn);
00246         Update((UINT_8 *)uData, SHA1_MAX_FILE_BUFFER);
00247     }
00248 
00249     if(ulRest != 0) {
00250         fread(uData, 1, ulRest, fIn);
00251         Update((UINT_8 *)uData, ulRest);
00252     }
00253 
00254     fclose(fIn);
00255     fIn = NULL;
00256     return true;
00257 }

void CSHA1::Final (  ) 

00261 {
00262     UINT_32 i;
00263     UINT_8 finalcount[8];
00264 
00265     for(i = 0; i < 8; i++)
00266         finalcount[i] = (UINT_8)((m_count[((i >= 4) ? 0 : 1)]
00267                                   >> ((3 - (i & 3)) * 8) ) & 255); // Endian independent
00268 
00269     Update((UINT_8 *)"\200", 1);
00270 
00271     while ((m_count[0] & 504) != 448)
00272         Update((UINT_8 *)"\0", 1);
00273 
00274     Update(finalcount, 8); // Cause a SHA1Transform()
00275 
00276     for(i = 0; i < 20; i++) {
00277         m_digest[i] = (UINT_8)((m_state[i >> 2] >> ((3 - (i & 3)) * 8) ) & 255);
00278     }
00279 
00280     // Wipe variables for security reasons
00281 #ifdef SHA1_WIPE_VARIABLES
00282     i = 0;
00283     memset(m_buffer, 0, 64);
00284     memset(m_state, 0, 20);
00285     memset(m_count, 0, 8);
00286     memset(finalcount, 0, 8);
00287     Transform(m_state, m_buffer);
00288 #endif
00289 }

void CSHA1::ReportHash ( char *  szReport,
unsigned char  uReportType = REPORT_HEX 
)

00294 {
00295     unsigned char i;
00296     char szTemp[16];
00297 
00298     if(szReport == NULL)
00299         return;
00300 
00301     if(uReportType == REPORT_HEX) {
00302         //sprintf(szTemp, "%02x", m_digest[0]);
00303         //strcat(szReport, szTemp);
00304 
00305         for(i = 0; i < 20; i++) {
00306             sprintf(szTemp, "%02x", m_digest[i]);
00307             strcat(szReport, szTemp);
00308         }
00309     } else if(uReportType == REPORT_DIGIT) {
00310         sprintf(szTemp, "%u", m_digest[0]);
00311         strcat(szReport, szTemp);
00312 
00313         for(i = 1; i < 20; i++) {
00314             sprintf(szTemp, " %u", m_digest[i]);
00315             strcat(szReport, szTemp);
00316         }
00317     } else
00318         strcpy(szReport, "Error: Unknown report type!");
00319 }

void CSHA1::GetHash ( UINT_8 *  puDest  ) 

00324 {
00325     memcpy(puDest, m_digest, 20);
00326 }

void CSHA1::Transform ( UINT_32 *  state,
UINT_8 *  buffer 
) [private]

00087 {
00088     // Copy state[] to working vars
00089     UINT_32 a = state[0], b = state[1], c = state[2], d = state[3], e = state[4];
00090 
00091     memcpy(m_block, buffer, 64);
00092 
00093     // 4 rounds of 20 operations each. Loop unrolled.
00094     _R0(a,b,c,d,e, 0);
00095     _R0(e,a,b,c,d, 1);
00096     _R0(d,e,a,b,c, 2);
00097     _R0(c,d,e,a,b, 3);
00098     _R0(b,c,d,e,a, 4);
00099     _R0(a,b,c,d,e, 5);
00100     _R0(e,a,b,c,d, 6);
00101     _R0(d,e,a,b,c, 7);
00102     _R0(c,d,e,a,b, 8);
00103     _R0(b,c,d,e,a, 9);
00104     _R0(a,b,c,d,e,10);
00105     _R0(e,a,b,c,d,11);
00106     _R0(d,e,a,b,c,12);
00107     _R0(c,d,e,a,b,13);
00108     _R0(b,c,d,e,a,14);
00109     _R0(a,b,c,d,e,15);
00110     _R1(e,a,b,c,d,16);
00111     _R1(d,e,a,b,c,17);
00112     _R1(c,d,e,a,b,18);
00113     _R1(b,c,d,e,a,19);
00114     _R2(a,b,c,d,e,20);
00115     _R2(e,a,b,c,d,21);
00116     _R2(d,e,a,b,c,22);
00117     _R2(c,d,e,a,b,23);
00118     _R2(b,c,d,e,a,24);
00119     _R2(a,b,c,d,e,25);
00120     _R2(e,a,b,c,d,26);
00121     _R2(d,e,a,b,c,27);
00122     _R2(c,d,e,a,b,28);
00123     _R2(b,c,d,e,a,29);
00124     _R2(a,b,c,d,e,30);
00125     _R2(e,a,b,c,d,31);
00126     _R2(d,e,a,b,c,32);
00127     _R2(c,d,e,a,b,33);
00128     _R2(b,c,d,e,a,34);
00129     _R2(a,b,c,d,e,35);
00130     _R2(e,a,b,c,d,36);
00131     _R2(d,e,a,b,c,37);
00132     _R2(c,d,e,a,b,38);
00133     _R2(b,c,d,e,a,39);
00134     _R3(a,b,c,d,e,40);
00135     _R3(e,a,b,c,d,41);
00136     _R3(d,e,a,b,c,42);
00137     _R3(c,d,e,a,b,43);
00138     _R3(b,c,d,e,a,44);
00139     _R3(a,b,c,d,e,45);
00140     _R3(e,a,b,c,d,46);
00141     _R3(d,e,a,b,c,47);
00142     _R3(c,d,e,a,b,48);
00143     _R3(b,c,d,e,a,49);
00144     _R3(a,b,c,d,e,50);
00145     _R3(e,a,b,c,d,51);
00146     _R3(d,e,a,b,c,52);
00147     _R3(c,d,e,a,b,53);
00148     _R3(b,c,d,e,a,54);
00149     _R3(a,b,c,d,e,55);
00150     _R3(e,a,b,c,d,56);
00151     _R3(d,e,a,b,c,57);
00152     _R3(c,d,e,a,b,58);
00153     _R3(b,c,d,e,a,59);
00154     _R4(a,b,c,d,e,60);
00155     _R4(e,a,b,c,d,61);
00156     _R4(d,e,a,b,c,62);
00157     _R4(c,d,e,a,b,63);
00158     _R4(b,c,d,e,a,64);
00159     _R4(a,b,c,d,e,65);
00160     _R4(e,a,b,c,d,66);
00161     _R4(d,e,a,b,c,67);
00162     _R4(c,d,e,a,b,68);
00163     _R4(b,c,d,e,a,69);
00164     _R4(a,b,c,d,e,70);
00165     _R4(e,a,b,c,d,71);
00166     _R4(d,e,a,b,c,72);
00167     _R4(c,d,e,a,b,73);
00168     _R4(b,c,d,e,a,74);
00169     _R4(a,b,c,d,e,75);
00170     _R4(e,a,b,c,d,76);
00171     _R4(d,e,a,b,c,77);
00172     _R4(c,d,e,a,b,78);
00173     _R4(b,c,d,e,a,79);
00174 
00175     // Add the working vars back into state
00176     state[0] += a;
00177     state[1] += b;
00178     state[2] += c;
00179     state[3] += d;
00180     state[4] += e;
00181 
00182     // Wipe variables
00183 #ifdef SHA1_WIPE_VARIABLES
00184 
00185     a = b = c = d = e = 0;
00186 #endif
00187 }


Member Data Documentation

UINT_32 CSHA1::m_state[5]

UINT_32 CSHA1::m_count[2]

UINT_32 CSHA1::__reserved1[1]

UINT_8 CSHA1::m_buffer[64]

UINT_8 CSHA1::m_digest[20]

UINT_32 CSHA1::__reserved2[3]

UINT_8 CSHA1::m_workspace[64] [private]

SHA1_WORKSPACE_BLOCK* CSHA1::m_block [private]


The documentation for this class was generated from the following files:
Generated on Thu Apr 17 13:19:28 2008 for ITM OverSim by  doxygen 1.5.3