Ruby 1.9.2p136(2010-12-25revision30365)

- Main Page
- Modules
- Data Structures
- Files

- File List
- Globals

# ext/digest/sha2/sha2.h

Go to the documentation of this file.

    00001 /*
    00002  * FILE:        sha2.h
    00003  * AUTHOR:      Aaron D. Gifford - http://www.aarongifford.com/
    00004  *
    00005  * Copyright (c) 2000-2001, Aaron D. Gifford
    00006  * All rights reserved.
    00007  *
    00008  * Redistribution and use in source and binary forms, with or without
    00009  * modification, are permitted provided that the following conditions
    00010  * are met:
    00011  * 1. Redistributions of source code must retain the above copyright
    00012  *    notice, this list of conditions and the following disclaimer.
    00013  * 2. Redistributions in binary form must reproduce the above copyright
    00014  *    notice, this list of conditions and the following disclaimer in the
    00015  *    documentation and/or other materials provided with the distribution.
    00016  * 3. Neither the name of the copyright holder nor the names of contributors
    00017  *    may be used to endorse or promote products derived from this software
    00018  *    without specific prior written permission.
    00019  *
    00020  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
    00021  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    00022  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    00023  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
    00024  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    00025  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    00026  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    00027  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    00028  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    00029  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    00030  * SUCH DAMAGE.
    00031  *
    00032  * $OrigId: sha2.h,v 1.1 2001/11/08 00:02:01 adg Exp adg $
    00033  * $RoughId: sha2.h,v 1.3 2002/02/24 08:14:32 knu Exp $
    00034  * $Id: sha2.h 27437 2010-04-22 08:04:13Z nobu $
    00035  */
    00036
    00037 #ifndef __SHA2_H__
    00038 #define __SHA2_H__
    00039
    00040 #ifdef __cplusplus
    00041 extern "C" {
    00042 #endif
    00043
    00044
    00045 /*
    00046  * Import u_intXX_t size_t type definitions from system headers.  You
    00047  * may need to change this, or define these things yourself in this
    00048  * file.
    00049  */
    00050 #include <sys/types.h>
    00051
    00052 #ifdef RUBY
    00053 # ifdef HAVE_PROTOTYPES
    00054 #  undef NOPROTO
    00055 # else
    00056 #  define NOPROTO
    00057 # endif /* HAVE_PROTOTYPES */
    00058 # ifndef BYTE_ORDER
    00059 #  define LITTLE_ENDIAN 1234
    00060 #  define BIG_ENDIAN    4321
    00061 #  ifdef WORDS_BIGENDIAN
    00062 #   define BYTE_ORDER   BIG_ENDIAN
    00063 #  else
    00064 #   define BYTE_ORDER   LITTLE_ENDIAN
    00065 #  endif
    00066 # endif /* BYTE_ORDER */
    00067 # define SHA2_USE_INTTYPES_H
    00068 #else /* RUBY */
    00069 #ifdef SHA2_USE_INTTYPES_H
    00070
    00071 #include <inttypes.h>
    00072
    00073 #endif /* SHA2_USE_INTTYPES_H */
    00074 #endif /* RUBY */
    00075
    00076
    00077 /*** SHA-256/384/512 Various Length Definitions ***********************/
    00078 #define SHA256_BLOCK_LENGTH             64
    00079 #define SHA256_DIGEST_LENGTH            32
    00080 #define SHA256_DIGEST_STRING_LENGTH     (SHA256_DIGEST_LENGTH * 2 + 1)
    00081 #define SHA384_BLOCK_LENGTH             128
    00082 #define SHA384_DIGEST_LENGTH            48
    00083 #define SHA384_DIGEST_STRING_LENGTH     (SHA384_DIGEST_LENGTH * 2 + 1)
    00084 #define SHA512_BLOCK_LENGTH             128
    00085 #define SHA512_DIGEST_LENGTH            64
    00086 #define SHA512_DIGEST_STRING_LENGTH     (SHA512_DIGEST_LENGTH * 2 + 1)
    00087
    00088
    00089 /*** SHA-256/384/512 Context Structures *******************************/
    00090 /* NOTE: If your architecture does not define either u_intXX_t types or
    00091  * uintXX_t (from inttypes.h), you may need to define things by hand
    00092  * for your system:
    00093  */
    00094 #ifndef SHA2_USE_INTTYPES_H
    00095 # ifdef HAVE_U_INT8_T
    00096 typedef u_int8_t uint8_t;               /* 1-byte  (8-bits)  */
    00097 typedef u_int32_t uint32_t;             /* 4-bytes (32-bits) */
    00098 typedef u_int64_t uint64_t;             /* 8-bytes (64-bits) */
    00099 # else
    00100 typedef unsigned char uint8_t;          /* 1-byte  (8-bits)  */
    00101 typedef unsigned int uint32_t;          /* 4-bytes (32-bits) */
    00102 typedef unsigned long long uint64_t;    /* 8-bytes (64-bits) */
    00103 # endif
    00104 #endif
    00105
    00106 /*
    00107  * Most BSD systems already define u_intXX_t types, as does Linux.
    00108  * Some systems, however, like Compaq's Tru64 Unix instead can use
    00109  * uintXX_t types defined by very recent ANSI C standards and included
    00110  * in the file:
    00111  *
    00112  *   #include <inttypes.h>
    00113  *
    00114  * If you choose to use <inttypes.h> then please define:
    00115  *
    00116  *   #define SHA2_USE_INTTYPES_H
    00117  *
    00118  * Or on the command line during compile:
    00119  *
    00120  *   cc -DSHA2_USE_INTTYPES_H ...
    00121  */
    00122 typedef struct _SHA256_CTX {
    00123         uint32_t        state[8];
    00124         uint64_t        bitcount;
    00125         uint8_t buffer[SHA256_BLOCK_LENGTH];
    00126 } SHA256_CTX;
    00127 typedef struct _SHA512_CTX {
    00128         uint64_t        state[8];
    00129         uint64_t        bitcount[2];
    00130         uint8_t buffer[SHA512_BLOCK_LENGTH];
    00131 } SHA512_CTX;
    00132
    00133 typedef SHA512_CTX SHA384_CTX;
    00134
    00135
    00136 /*** SHA-256/384/512 Function Prototypes ******************************/
    00137 #ifdef RUBY
    00138 #define SHA256_Init             rb_Digest_SHA256_Init
    00139 #define SHA256_Update           rb_Digest_SHA256_Update
    00140 #define SHA256_Finish           rb_Digest_SHA256_Finish
    00141 #define SHA256_Data             rb_Digest_SHA256_Data
    00142 #define SHA256_End              rb_Digest_SHA256_End
    00143 #define SHA256_Last             rb_Digest_SHA256_Last
    00144 #define SHA256_Transform        rb_Digest_SHA256_Transform
    00145 #define SHA256_Final(d, c)      SHA256_Finish(c, d)
    00146
    00147 #define SHA384_Init             rb_Digest_SHA384_Init
    00148 #define SHA384_Update           rb_Digest_SHA384_Update
    00149 #define SHA384_Finish           rb_Digest_SHA384_Finish
    00150 #define SHA384_Data             rb_Digest_SHA384_Data
    00151 #define SHA384_End              rb_Digest_SHA384_End
    00152 #define SHA384_Last             rb_Digest_SHA384_Last
    00153 #define SHA384_Transform        rb_Digest_SHA384_Transform
    00154 #define SHA384_Final(d, c)      SHA384_Finish(c, d)
    00155
    00156 #define SHA512_Init             rb_Digest_SHA512_Init
    00157 #define SHA512_Update           rb_Digest_SHA512_Update
    00158 #define SHA512_Finish           rb_Digest_SHA512_Finish
    00159 #define SHA512_Data             rb_Digest_SHA512_Data
    00160 #define SHA512_End              rb_Digest_SHA512_End
    00161 #define SHA512_Last             rb_Digest_SHA512_Last
    00162 #define SHA512_Transform        rb_Digest_SHA512_Transform
    00163 #define SHA512_Final(d, c)      SHA512_Finish(c, d)
    00164 #endif /* RUBY */
    00165
    00166 #ifndef NOPROTO
    00167
    00168 void SHA256_Init(SHA256_CTX *);
    00169 void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t);
    00170 void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
    00171 char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
    00172 char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
    00173
    00174 void SHA384_Init(SHA384_CTX*);
    00175 void SHA384_Update(SHA384_CTX*, const uint8_t*, size_t);
    00176 void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
    00177 char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
    00178 char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
    00179
    00180 void SHA512_Init(SHA512_CTX*);
    00181 void SHA512_Update(SHA512_CTX*, const uint8_t*, size_t);
    00182 void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
    00183 char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
    00184 char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
    00185
    00186 #else /* NOPROTO */
    00187
    00188 void SHA256_Init();
    00189 void SHA256_Update();
    00190 #ifdef RUBY
    00191 void SHA256_Finish();
    00192 #else
    00193 void SHA256_Final();
    00194 #endif /* RUBY */
    00195 char* SHA256_End();
    00196 char* SHA256_Data();
    00197
    00198 void SHA384_Init();
    00199 void SHA384_Update();
    00200 #ifdef RUBY
    00201 void SHA384_Finish();
    00202 #else
    00203 void SHA384_Final();
    00204 #endif /* RUBY */
    00205 char* SHA384_End();
    00206 char* SHA384_Data();
    00207
    00208 void SHA512_Init();
    00209 void SHA512_Update();
    00210 #ifdef RUBY
    00211 void SHA512_Finish();
    00212 #else
    00213 void SHA512_Final();
    00214 #endif /* RUBY */
    00215 char* SHA512_End();
    00216 char* SHA512_Data();
    00217
    00218 #endif /* NOPROTO */
    00219
    00220 #ifdef  __cplusplus
    00221 }
    00222 #endif /* __cplusplus */
    00223
    00224 #endif /* __SHA2_H__ */
    00225
    00226