highscores can now be submitted to and retrieved from a server
This commit is contained in:
@@ -4,6 +4,7 @@ LIST( APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake )
|
||||
|
||||
FIND_PACKAGE (SDL REQUIRED)
|
||||
FIND_PACKAGE (SDL_mixer REQUIRED)
|
||||
FIND_PACKAGE (SDL_net REQUIRED)
|
||||
FIND_PACKAGE (OpenGL REQUIRED)
|
||||
FIND_PACKAGE (PNG REQUIRED)
|
||||
FIND_PACKAGE (FreeType2 REQUIRED)
|
||||
@@ -43,10 +44,12 @@ SET ( ENGINE_SRCS
|
||||
INCLUDE_DIRECTORIES (
|
||||
${Boost_INCLUDE_DIRS}
|
||||
${SDLMIXER_INCLUDE_DIRS}
|
||||
${SDLNET_INCLUDE_DIRS}
|
||||
${PROJECT_SOURCE_DIR}
|
||||
libraries/mathlib/
|
||||
libraries/coll2d/include
|
||||
libraries/oglft/liboglft
|
||||
libraries/sha2/
|
||||
${FREETYPE2_INCLUDE_DIR}
|
||||
)
|
||||
|
||||
@@ -55,12 +58,14 @@ ADD_LIBRARY ( Engine STATIC ${ENGINE_SRCS} )
|
||||
TARGET_LINK_LIBRARIES ( Engine
|
||||
${SDL_LIBRARY}
|
||||
${SDLMIXER_LIBRARY}
|
||||
${SDLNET_LIBRARY}
|
||||
${OPENGL_LIBRARIES}
|
||||
${PNG_LIBRARIES}
|
||||
${Boost_LIBRARIES}
|
||||
mathlib
|
||||
oglft
|
||||
coll2d
|
||||
sha2
|
||||
)
|
||||
|
||||
ADD_SUBDIRECTORY ( tests )
|
||||
|
||||
+10
-6
@@ -37,6 +37,8 @@ int Engine::OnInit (int argc, char* argv[]) {
|
||||
EngineInstance = this;
|
||||
mStatus = EngineStatusUndefined;
|
||||
|
||||
/* Phase 0: Logging, Events, Variables, Commands, SDL */
|
||||
|
||||
/* Initialization of the base modules */
|
||||
if (mLogging == NULL)
|
||||
mLogging = new Logging ();
|
||||
@@ -77,6 +79,13 @@ int Engine::OnInit (int argc, char* argv[]) {
|
||||
}
|
||||
SDL_WM_SetCaption("Engine Initializing","Engine Initializing");
|
||||
|
||||
/* Now register the commands */
|
||||
mLogging->RegisterCommands ();
|
||||
mVariables->RegisterCommands ();
|
||||
mCommands->RegisterCommands ();
|
||||
|
||||
/* Phase 1: Sounds, Model, EntityFactory, Physics, View, Camera, Controller*/
|
||||
|
||||
/* Sound */
|
||||
mSoundManager = new SoundBase();
|
||||
mSoundManager->Init (argc, argv);
|
||||
@@ -96,7 +105,6 @@ int Engine::OnInit (int argc, char* argv[]) {
|
||||
|
||||
mModel->mEntityFactory = mEntityFactory;
|
||||
|
||||
|
||||
/* Physics */
|
||||
if (mPhysics == NULL) {
|
||||
mPhysics = new PhysicsBase ();
|
||||
@@ -142,11 +150,7 @@ int Engine::OnInit (int argc, char* argv[]) {
|
||||
|
||||
mController->Init (argc, argv);
|
||||
|
||||
/* Now register the commands */
|
||||
mLogging->RegisterCommands ();
|
||||
mVariables->RegisterCommands ();
|
||||
mCommands->RegisterCommands ();
|
||||
|
||||
|
||||
mModel->mPhysics->RegisterCommands ();
|
||||
mModel->RegisterCommands ();
|
||||
|
||||
|
||||
@@ -546,6 +546,151 @@ bool LineEdit (int id, int x, int y, std::string &text_value, const int &maxleng
|
||||
return false;
|
||||
}
|
||||
|
||||
bool LineEditMasked (int id, int x, int y, std::string &text_value, const int &maxlength, const std::string &valid_chars) {
|
||||
controller = EngineGetController();
|
||||
assert (controller);
|
||||
|
||||
int textpos_x = x + 8;
|
||||
int textpos_y = y + 5;
|
||||
|
||||
y -= 16;
|
||||
int w = maxlength * 16;
|
||||
int h = 30;
|
||||
|
||||
// LogMessage ("id = %d hotitem = %d activeitem = %d kbditem = %d key = %s", id, controller->uistate.hotitem, controller->uistate.activeitem, controller->uistate.kbditem, convert_keycode (controller->uistate.last_keysym));
|
||||
|
||||
// Check for hotness
|
||||
if (regionhit (x, y, w, h)) {
|
||||
controller->uistate.hotitem = id;
|
||||
if (controller->uistate.activeitem == 0
|
||||
&& controller->GetButtonState(MouseButtonLeft)) {
|
||||
controller->uistate.activeitem = id;
|
||||
}
|
||||
}
|
||||
|
||||
if (controller->uistate.kbditem == 0) {
|
||||
controller->uistate.hotitem = id;
|
||||
controller->uistate.kbditem = id;
|
||||
controller->uistate.last_unicode = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
// If we have keyboard focus, we highlight the widget
|
||||
if ( controller->uistate.kbditem == id) {
|
||||
if (controller->uistate.activeitem == id) {
|
||||
glColor3f (0.8, 0.8, 0.8);
|
||||
DrawBlock (x, y, w, h);
|
||||
} else {
|
||||
glColor3f (0.7, 0.7, 0.7);
|
||||
DrawBlock (x, y, w, h);
|
||||
}
|
||||
} else {
|
||||
glColor3f (0.4, 0.4, 0.4);
|
||||
DrawBlock (x, y, w, h);
|
||||
}
|
||||
|
||||
// Rendering of the current value
|
||||
float width, height;
|
||||
view = EngineGetView ();
|
||||
assert (view);
|
||||
|
||||
glColor3f (1., 1., 1.);
|
||||
|
||||
std::string text_output = text_value;
|
||||
|
||||
if (controller->uistate.kbditem == id && SDL_GetTicks() >> 9 & 1)
|
||||
text_output += "_";
|
||||
|
||||
SelectFont("console.ttf size=23");
|
||||
view->DrawGLStringMeasure(text_value.c_str(), &width, &height);
|
||||
view->DrawGLString(textpos_x, textpos_y, text_output.c_str());
|
||||
|
||||
// Keyboard Logic
|
||||
if (controller->uistate.kbditem == id) {
|
||||
switch (controller->uistate.last_keysym) {
|
||||
case SDLK_DOWN:
|
||||
controller->uistate.kbditem = 0;
|
||||
controller->uistate.hotitem = 0;
|
||||
controller->uistate.last_keysym = SDLK_CLEAR;
|
||||
break;
|
||||
case SDLK_UP:
|
||||
controller->uistate.kbditem = controller->uistate.lastwidget;
|
||||
controller->uistate.hotitem = controller->uistate.lastwidget;
|
||||
controller->uistate.last_keysym = SDLK_CLEAR;
|
||||
break;
|
||||
case SDLK_CLEAR:
|
||||
controller->uistate.last_keysym = SDLK_CLEAR;
|
||||
controller->uistate.last_unicode = 0;
|
||||
return false;
|
||||
break;
|
||||
case SDLK_ESCAPE:
|
||||
controller->uistate.last_keysym = SDLK_CLEAR;
|
||||
controller->uistate.last_unicode = 0;
|
||||
controller->uistate.hotitem = 0;
|
||||
controller->uistate.kbditem = 0;
|
||||
return false;
|
||||
break;
|
||||
case SDLK_TAB:
|
||||
controller->uistate.last_keysym = SDLK_CLEAR;
|
||||
controller->uistate.last_unicode = 0;
|
||||
controller->uistate.hotitem = 0;
|
||||
controller->uistate.kbditem = 0;
|
||||
return false;
|
||||
break;
|
||||
case SDLK_RETURN:
|
||||
controller->uistate.last_keysym = SDLK_CLEAR;
|
||||
controller->uistate.last_unicode = 0;
|
||||
controller->uistate.hotitem = 0;
|
||||
controller->uistate.kbditem = 0;
|
||||
return true;
|
||||
break;
|
||||
case SDLK_BACKSPACE:
|
||||
if (text_value.size() > 0) {
|
||||
text_value = text_value.substr(0, text_value.size() - 1);
|
||||
controller->uistate.last_keysym = SDLK_CLEAR;
|
||||
controller->uistate.last_unicode = 0;
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
// The raw input processing
|
||||
if (maxlength > 0 && text_value.size() < maxlength) {
|
||||
if (controller->uistate.last_unicode) {
|
||||
if ((controller->uistate.last_unicode & 0xFF80) == 0) {
|
||||
char c = controller->uistate.last_unicode & 0x7F;
|
||||
|
||||
// we do not want to add special characters such as backspaces
|
||||
// etc.
|
||||
if (c >= 0x20 && valid_chars.find(c) != std::string::npos ) {
|
||||
text_value += c;
|
||||
}
|
||||
controller->uistate.last_unicode = 0;
|
||||
return true;
|
||||
} else {
|
||||
LogWarning ("Input key not supported!");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
controller->uistate.lastwidget = id;
|
||||
|
||||
// Mouse Logic
|
||||
if (controller->GetButtonState(MouseButtonLeft) == false
|
||||
&& controller->uistate.hotitem == id
|
||||
&& controller->uistate.activeitem == id) {
|
||||
controller->uistate.kbditem = id;
|
||||
controller->uistate.last_unicode = 0;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
float VerticalSlider (int id, int x, int y, int w, int h, float min_value, float max_value, float &value) {
|
||||
const int knob_width = 16;
|
||||
const int knob_height = h * 2;
|
||||
|
||||
@@ -38,6 +38,8 @@ bool CheckButton (int id, const char* caption, bool state, int x, int y, int w,
|
||||
|
||||
bool LineEdit (int id, int x, int y, std::string &text_value, const int &maxlength);
|
||||
|
||||
bool LineEditMasked (int id, int x, int y, std::string &text_value, const int &maxlength, const std::string &valid_chars);
|
||||
|
||||
float VerticalSlider (int id, int x, int y, int w, int h, float min_value, float max_value, float &value);
|
||||
|
||||
/** \brief Checks whether a given key is currently pressed
|
||||
|
||||
@@ -7,7 +7,12 @@
|
||||
#include <boost/filesystem.hpp>
|
||||
#include <cstdlib>
|
||||
|
||||
#include <sha2.h>
|
||||
|
||||
std::string strip_whitespaces (const std::string input_str) {
|
||||
if (input_str.size() == 0)
|
||||
return input_str;
|
||||
|
||||
std::string result = input_str.substr(input_str.find_first_not_of (" \t\n\r"), input_str.size());
|
||||
return result.substr (0, result.find_last_not_of(" \t\n\r") + 1);
|
||||
}
|
||||
@@ -36,3 +41,15 @@ bool create_dir (const std::string &dir_str) {
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string sha256_hash (std::string input) {
|
||||
char result_buf[64];
|
||||
|
||||
SHA256_CTX ctx256;
|
||||
|
||||
SHA256_Init(&ctx256);
|
||||
SHA256_Update(&ctx256, (unsigned char*) input.c_str(), input.size());
|
||||
SHA256_End (&ctx256, result_buf);
|
||||
|
||||
return std::string (result_buf, 64);
|
||||
}
|
||||
|
||||
@@ -5,5 +5,6 @@
|
||||
|
||||
std::string strip_whitespaces (const std::string input_str);
|
||||
bool create_dir (const std::string &dir_str);
|
||||
std::string sha256_hash (std::string input);
|
||||
|
||||
#endif /* _UTILS_H */
|
||||
|
||||
+19
-1
@@ -63,6 +63,7 @@ Variable::Variable (const std::string &name, const std::string &value) {
|
||||
mName = name;
|
||||
mStringValue = value;
|
||||
mFloatValue = atof (value.c_str());
|
||||
mBoolValue = ParseBoolValue (value);
|
||||
|
||||
if (VariablesInstance == NULL) {
|
||||
delayed_variables.push_back (this);
|
||||
@@ -81,7 +82,7 @@ Variable::Variable (const std::string &name, const std::string &value) {
|
||||
}
|
||||
|
||||
void Variable::RegisterVariable (const std::string &name) {
|
||||
if (! VariablesInstance ) {
|
||||
if (! VariablesInstance ) {
|
||||
LogError ("Unable to register Variable '%s': Variables System not initialized!", name.c_str());
|
||||
return;
|
||||
}
|
||||
@@ -89,6 +90,23 @@ void Variable::RegisterVariable (const std::string &name) {
|
||||
VariablesInstance->RegisterVariable (name, this);
|
||||
}
|
||||
|
||||
bool Variable::ParseBoolValue (std::string value) {
|
||||
float float_value = atof (value.c_str());
|
||||
|
||||
if (float_value != 0.)
|
||||
return true;
|
||||
|
||||
// transform to upper case
|
||||
unsigned int i;
|
||||
for (i = 0; i < value.size(); i++)
|
||||
value[i] = tolower (value[i]);
|
||||
// std::transform (value.begin(), value.end(), value.begin(), ::tolower);
|
||||
|
||||
if (value == "true"
|
||||
|| value == "yes")
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Global functions
|
||||
*/
|
||||
|
||||
@@ -26,6 +26,7 @@ bool Cmd_Set (const std::vector<std::string> args) {
|
||||
if (test) {
|
||||
test->SetStringValue (args[1]);
|
||||
test->SetFloatValue (atof (args[1].c_str()));
|
||||
test->SetBoolValueFromString (args[1]);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -29,12 +29,22 @@ class Variable {
|
||||
float& GetFloatValue () {
|
||||
return mFloatValue;
|
||||
}
|
||||
/** \brief Returns the float value of the Variable */
|
||||
bool& GetBoolValue () {
|
||||
return mBoolValue;
|
||||
}
|
||||
void SetStringValue (const std::string &value) {
|
||||
mStringValue = value;
|
||||
}
|
||||
void SetFloatValue (float value) {
|
||||
mFloatValue = value;
|
||||
}
|
||||
void SetBoolValue (bool value) {
|
||||
mBoolValue = value;
|
||||
}
|
||||
void SetBoolValueFromString (std::string str_value) {
|
||||
mBoolValue = ParseBoolValue (str_value);
|
||||
}
|
||||
|
||||
private:
|
||||
/** \brief The default constructor must not be used.
|
||||
@@ -48,9 +58,21 @@ class Variable {
|
||||
/** \brief Registeres this Variable with the Variables System */
|
||||
void RegisterVariable (const std::string &name);
|
||||
|
||||
/** \brief Parses the input value and checks whether it resembles true or not
|
||||
*
|
||||
* Valid true expressions are:
|
||||
* - any float values that are unequal to zero
|
||||
* - true (case insensitive)
|
||||
* - yes (case insensitive)
|
||||
*
|
||||
* \returns true if value contains a value that qualifies as a valid "true" expression
|
||||
*/
|
||||
bool ParseBoolValue (std::string value);
|
||||
|
||||
std::string mName;
|
||||
std::string mStringValue;
|
||||
float mFloatValue;
|
||||
bool mBoolValue;
|
||||
|
||||
friend class Variables;
|
||||
};
|
||||
@@ -63,6 +85,9 @@ bool SetVariableValue (const std::string &name, const std::string &value);
|
||||
std::string& GetVariableString (const std::string &name, std::string def = "");
|
||||
/** \brief Returns the float value of the Variable with the given name */
|
||||
float& GetVariableFloat (const std::string &name, float def = 0.);
|
||||
/** \brief Returns the boolean value of the Variable with the given name */
|
||||
bool& GetVariableBool (const std::string &name, bool def = false);
|
||||
|
||||
|
||||
}
|
||||
#endif // _VARIABLESGLOBAL_H
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
ADD_SUBDIRECTORY ( mathlib )
|
||||
ADD_SUBDIRECTORY ( coll2d )
|
||||
ADD_SUBDIRECTORY ( oglft )
|
||||
ADD_SUBDIRECTORY ( sha2 )
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
PROJECT (SHA2 CXX)
|
||||
|
||||
SET ( SRCS
|
||||
sha2.c
|
||||
)
|
||||
ADD_LIBRARY ( sha2 STATIC sha2.c)
|
||||
@@ -0,0 +1,272 @@
|
||||
VERSION:
|
||||
|
||||
This is version 1.0 RELEASE
|
||||
|
||||
While this is my "release" version, due to lack of additional
|
||||
official test vectors against which to verify this implementation's
|
||||
correctness, beware that there may be implementation bugs. Also,
|
||||
it has not yet been tested on very many other architectures,
|
||||
big-endian machines in particular.
|
||||
|
||||
|
||||
LICENSE:
|
||||
|
||||
This implementation is released freely under an open-source BSD
|
||||
license which appears at the top of each source code file.
|
||||
|
||||
|
||||
WHAT IT IS:
|
||||
|
||||
The files sha2.h and sha2.c implement the SHA-256, SHA-384, and SHA-512
|
||||
hash algorithms as described in the PDF document found at the following
|
||||
web address:
|
||||
|
||||
http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf
|
||||
|
||||
The interface is similar to the interface to SHA-1 found in the OpenSSL
|
||||
library.
|
||||
|
||||
The file sha2prog.c is a simple program that accepts input from either
|
||||
STDIN or reads one or more files specified on the command line, and then
|
||||
generates the specified hash (either SHA-256, SHA-384, SHA-512, or any
|
||||
combination thereof, including all three at once).
|
||||
|
||||
|
||||
LIMITATIONS:
|
||||
|
||||
This implementation has several limitations:
|
||||
|
||||
* Input data is only accepted in octet-length increments. No sub-byte
|
||||
data is handled. The NIST document describes how to handle sub-byte
|
||||
input data, but for ease of implementation this version will only
|
||||
accept message data in multiples of bytes.
|
||||
* This implementation utilizes 64-bit integer data types. If your
|
||||
system and compiler does not have a 64-bit integer data type, this
|
||||
implementation will not work.
|
||||
* Because of the use of 64-bit operations, many 32-bit architectures
|
||||
that do have 64-bit data types but do operations most efficiently
|
||||
on 32-bit words, this implementation may be slower than an
|
||||
implementation designed to use only 32-bit words (emulating the
|
||||
64-bit operations).
|
||||
* On platforms with 128-bit integer data types, the SHA-384 and SHA-512
|
||||
bit counters used by this implementation might be better off using
|
||||
the 128-bit type instead of simulating it with two 64-bit integers.
|
||||
* This implementation was written in C in hopes of portability and for
|
||||
the fun of it during my spare time. It is probably not the most
|
||||
efficient or fastest C implementation. I welcome suggestions,
|
||||
however, that suggest ways to speed things up without breaking
|
||||
portability. I also welcome suggestions to improve portability.
|
||||
* As mentioned above, this code has NOT been thoroughly tested.
|
||||
This is perhaps the most severe limitation.
|
||||
|
||||
|
||||
BEFORE YOU COMPILE (OPTIONS):
|
||||
|
||||
Each of the options described below may either be defined in the sha2.h
|
||||
header file (or in the sha2.c file in some cases), or on the command
|
||||
line at compile time if your compiler supports such things. For
|
||||
example:
|
||||
|
||||
#define SHA2_USE_INTTYPES_H
|
||||
#define SHA2_UNROLL_TRANSFORM
|
||||
|
||||
Or:
|
||||
|
||||
cc -c -DSHA2_UNROLL_TRANSFORM sha2.c
|
||||
cc -c -DBYTE_ORDER=4321 -DBIG_ENDIAN=4321 sha2.c
|
||||
|
||||
Here are the available options. Read on below for a description of
|
||||
each one:
|
||||
|
||||
SHA2_USE_INTTYPES_H
|
||||
SHA2_USE_MEMSET_MEMCPY/SHA2_USE_BZERO_BCOPY
|
||||
SHA2_UNROLL_TRANSFORM
|
||||
BYTE_ORDER (LITTLE_ENDIAN/BIG_ENDIAN)
|
||||
|
||||
* SHA2_USE_INTTYPES_H option:
|
||||
By default, this code uses u_intXX_t data types for 8 bit, 32 bit, and
|
||||
64 bit unsigned integer type definitions. Most BSD systems define these,
|
||||
as does Linux. However, some (like Compaq's Tru64 Unix) may instead
|
||||
use uintXX_t data types as defined by recent ANSI C standards and as
|
||||
included in the inttypes.h header file. Those wanting to use inttypes.h
|
||||
need to define this either in sha.h or at compile time.
|
||||
|
||||
On those systems where NEITHER definitions are available, you will need
|
||||
to edit both sha2.h and sha2.c and define things by hand in the appropriate
|
||||
sections.
|
||||
|
||||
* BYTE_ORDER definitions:
|
||||
This code assumes that BYTE_ORDER will be defined by the system during
|
||||
compile to either equal LITTLE_ENDIAN or BIG_ENDIAN. If your system
|
||||
does not define these, you may need to define them by hand in the sha.c
|
||||
file according to the byte ordering conventions of your system.
|
||||
|
||||
* SHA2_USE_MEMSET_MEMCPY or SHA2_USE_BZERO_BCOPY
|
||||
The code in sha2.c can use either memset()/memcpy() for memory block
|
||||
operations, or bzero()/mcopy(). If you define neither of these, the
|
||||
code will default to memset()/memcpy(). You can define either at the
|
||||
command line or in sha2.h or in sha2.c.
|
||||
|
||||
* SHA2_UNROLL_TRANSFORM
|
||||
By defining this either on the command line or in sha2.h or sha2.c,
|
||||
the code will use macros to partially "unroll" the SHA transform
|
||||
function. This usually generates bigger executables. It CAN (but
|
||||
not necessarily WILL) generate faster code when you tell your compiler
|
||||
to optimize things. For example, on the FreeBSD and Linux x86 systems
|
||||
I tested things on (using gcc), when I optimized with just -O2 and
|
||||
unrolled the transform, the hash transform was faster by 15-30%. On
|
||||
these same systems, if I did NO optimization, the unrolled transform
|
||||
was SLOWER, much slower (I'm guessing because the code was breaking
|
||||
the cache, but I'm not sure). Your mileage may vary.
|
||||
|
||||
|
||||
PORTABILITY:
|
||||
|
||||
The code in sha2.c and sha2.h is intended to be portable. It may
|
||||
require that you do a few #definitions in the .h file. I've successfully
|
||||
compiled and tested the sha2.c and sha2.h code on Apple's OS X (on
|
||||
a PPC), FreeBSD 4.1.1 on Intel, Linux on Intel, FreeBSD on the Alpha,
|
||||
and even under Windows98SE using Metrowerks C. The utility/example
|
||||
programs (sha2prog.c, sha2test.c, and sha2speed.c) will very likely
|
||||
have more trouble in portability since they do I/O.
|
||||
|
||||
To get sha2.c/sha2.h working under Windows, I had to define
|
||||
SHA2_USE_INTTYPES_H, BYTE_ORDER, LITTLE_ENDIAN, and had to comment
|
||||
out the include of <sys/types.h> in sha2.h. With a bit more work
|
||||
I got the test program to run and verified that all the test
|
||||
cases passed.
|
||||
|
||||
|
||||
SUGGESTIONS/BUG FIXES:
|
||||
|
||||
If you make changes to get it working on other architectures, if you fix
|
||||
any bugs, or if you make changes that improve this implementation's
|
||||
efficiency that would be relatively portable and you're willing to release
|
||||
your changes under the same license, please send them to me for possible
|
||||
inclusion in future versions.
|
||||
|
||||
If you know where I can find some additional test vectors, please let me
|
||||
know.
|
||||
|
||||
|
||||
CHANGE HISTORY:
|
||||
|
||||
0.8 to 0.9 - Fixed spelling errors, changed to u_intXX_t type usage,
|
||||
removed names from prototypes, added prototypes to sha2.c,
|
||||
and a few things I can't recall.
|
||||
|
||||
0.9 to 0.9.5 - Add a new define in sha2.c that permits one to compile
|
||||
it to either use memcpy()/memset() or bcopy()/bzero()
|
||||
for memory block copying and zeroing. Added support
|
||||
for unrolled SHA-256/384/512 transform loops. Just
|
||||
compile with SHA2_UNROLL_TRANSFORM to enable. It takes
|
||||
longer to compile, but I hope it is a bit faster. I
|
||||
need to do some test to see whether or not it is. Oh,
|
||||
in sha2.c, you either need to define SHA2_USE_BZERO_BCOPY
|
||||
or SHA2_USE_MEMSET_MEMCPY to choose which way you want
|
||||
to compile. *Whew* It's amazing how quickly something
|
||||
simple starts to grow more complex even in the span of
|
||||
just a few hours. I didn't really intend to do this much.
|
||||
0.9.5 to 0.9.6 - Added a test program (sha2test) which tests against several
|
||||
known test vectors. WARNING: Some of the test output
|
||||
hashes are NOT from NIST's documentation and are the
|
||||
output of this implementation and so may be incorrect.
|
||||
0.9.6 to 0.9.7 - Fixed a bug that could cause invalid output in certain
|
||||
cases and added an assumed scenario where zero-length
|
||||
data is hashed. Also changed the rotation macros to use
|
||||
a temporary variable as this reduces the number of operations.
|
||||
When data is fed in blocks of the right length, copying of
|
||||
data is reduced in this version. Added SHAYXZ_Data()
|
||||
functions for ease of hashing a set of data. Added another
|
||||
file sha2speed.c for doing speed testing. Added another test
|
||||
vector with a larger data size (16KB). Fixed u_intXX_t and
|
||||
uintXX_t handling by adding a define for SHA2_USE_INTTYPES_H
|
||||
as well as made a few other minor changes to get rid of
|
||||
warnings when compiling on Compaq's Tru64 Unix.
|
||||
0.9.7 to 0.9.8 - The bug fix in 0.9.7 was incomplete and in some cases made
|
||||
things worse. I believe that 0.9.8 fixes the bug completely
|
||||
so that output is correct. I cannot verify this, however,
|
||||
because of the lack of test vectors against which to do such
|
||||
verification. All versions correctly matched the very few
|
||||
NIST-provided vectors, but unfortunately the bug only
|
||||
appeared in longer message data sets.
|
||||
0.9.8 to 0.9.9 - Fixed some really bad typos and mistakes on my part that
|
||||
only affected big-endian systems. I didn't have direct
|
||||
access for testing before this version. Thanks to
|
||||
Lucas Marshall for giving me access to his OS X system.
|
||||
0.9.9 to 1.0.0b1 Added a few more test samples and made a few changes to
|
||||
make things easier compiling on several other platforms.
|
||||
Also I experimented with alternate macro definitions
|
||||
in the SHA2_UNROLL_TRANSFORM version (see sha2.slower.c)
|
||||
and eliminated the T1 temporary variable (the compiler
|
||||
would of course still use internal temporary storage
|
||||
during expression evaluation, but I'd hoped the compiler
|
||||
would be more efficient), but unfortunately under FreeBSD
|
||||
4.1.1-STABLE on an x86 platform, the change slowed things
|
||||
down.
|
||||
1.0.0b1 to 1.0 RELEASE Fixed an off-by-one implementation bug that affected
|
||||
SHA-256 when hashed data length L = 55 + 64 * X where X is
|
||||
either zero or a positive integer, and another (basically
|
||||
the same bug) bug in SHA-384 and SHA-512 that showed up when
|
||||
hashed data lengths L = 111 + 128 * X. Thanks to Rogier
|
||||
van de Pol for sending me test data that revealed the bug.
|
||||
The fix was very simple (just two tiny changes). Also,
|
||||
I finally put the files into RCS so future changes will be
|
||||
easier to manage. The sha2prog.c file was rewritten to
|
||||
be more useful to me, and I got rid of the old C testing
|
||||
program and now use a perl script with a subdirectory full
|
||||
of test data. It's a more flexible test system.
|
||||
|
||||
|
||||
LATEST VERSION:
|
||||
|
||||
The latest version and documentation (if any ;) should always be available
|
||||
on the web at:
|
||||
|
||||
http://www.aarongifford.com/computers/sha.html
|
||||
|
||||
|
||||
CONTACT ME:
|
||||
|
||||
I can be reached via email at:
|
||||
|
||||
Aaron Gifford <m e @ a a r o n g i f f o r d . c o m>
|
||||
|
||||
Please don't send support questions. I don't have the time to answer and
|
||||
they'll probably be ignored. Bug fixes, or patches that add something useful
|
||||
will be gratefully accepted, however.
|
||||
|
||||
If you use this implementation, I would enjoy getting a brief email message
|
||||
letting me know who you are and what use to which it is being put. There
|
||||
is no requirement to do so. I just think it would be fun.
|
||||
|
||||
|
||||
EXAMPLES:
|
||||
|
||||
Here's an example of compiling and using the sha2 program (in this example
|
||||
I build it using the unrolled transform version with -O2 optimizations),
|
||||
and then running the perl testing script:
|
||||
|
||||
cc -O2 -DSHA2_UNROLL_TRANSFORM -Wall -o sha2 sha2prog.c sha2.c
|
||||
% ./sha2test.pl
|
||||
|
||||
[most of the perl script output deleted for brevity]
|
||||
|
||||
===== RESULTS (18 VECTOR DATA FILES HASHED) =====
|
||||
|
||||
HASH TYPE NO. OF TESTS PASSED FAILED
|
||||
--------- ------------ ------ ------
|
||||
SHA-256 18 18 0
|
||||
SHA-384 18 18 0
|
||||
SHA-512 18 18 0
|
||||
----------------------------------------------
|
||||
TOTAL: 54 54 0
|
||||
|
||||
NO ERRORS! ALL TESTS WERE SUCCESSFUL!
|
||||
|
||||
ALL TEST VECTORS PASSED!
|
||||
|
||||
That's all folks! Have fun!
|
||||
|
||||
Aaron out.
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,197 @@
|
||||
/*
|
||||
* FILE: sha2.h
|
||||
* AUTHOR: Aaron D. Gifford - http://www.aarongifford.com/
|
||||
*
|
||||
* Copyright (c) 2000-2001, Aaron D. Gifford
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. Neither the name of the copyright holder nor the names of contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* $Id: sha2.h,v 1.1 2001/11/08 00:02:01 adg Exp adg $
|
||||
*/
|
||||
|
||||
#ifndef __SHA2_H__
|
||||
#define __SHA2_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Import u_intXX_t size_t type definitions from system headers. You
|
||||
* may need to change this, or define these things yourself in this
|
||||
* file.
|
||||
*/
|
||||
#include <sys/types.h>
|
||||
|
||||
#ifdef SHA2_USE_INTTYPES_H
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
#endif /* SHA2_USE_INTTYPES_H */
|
||||
|
||||
|
||||
/*** SHA-256/384/512 Various Length Definitions ***********************/
|
||||
#define SHA256_BLOCK_LENGTH 64
|
||||
#define SHA256_DIGEST_LENGTH 32
|
||||
#define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1)
|
||||
#define SHA384_BLOCK_LENGTH 128
|
||||
#define SHA384_DIGEST_LENGTH 48
|
||||
#define SHA384_DIGEST_STRING_LENGTH (SHA384_DIGEST_LENGTH * 2 + 1)
|
||||
#define SHA512_BLOCK_LENGTH 128
|
||||
#define SHA512_DIGEST_LENGTH 64
|
||||
#define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1)
|
||||
|
||||
|
||||
/*** SHA-256/384/512 Context Structures *******************************/
|
||||
/* NOTE: If your architecture does not define either u_intXX_t types or
|
||||
* uintXX_t (from inttypes.h), you may need to define things by hand
|
||||
* for your system:
|
||||
*/
|
||||
#if 0
|
||||
typedef unsigned char u_int8_t; /* 1-byte (8-bits) */
|
||||
typedef unsigned int u_int32_t; /* 4-bytes (32-bits) */
|
||||
typedef unsigned long long u_int64_t; /* 8-bytes (64-bits) */
|
||||
#endif
|
||||
/*
|
||||
* Most BSD systems already define u_intXX_t types, as does Linux.
|
||||
* Some systems, however, like Compaq's Tru64 Unix instead can use
|
||||
* uintXX_t types defined by very recent ANSI C standards and included
|
||||
* in the file:
|
||||
*
|
||||
* #include <inttypes.h>
|
||||
*
|
||||
* If you choose to use <inttypes.h> then please define:
|
||||
*
|
||||
* #define SHA2_USE_INTTYPES_H
|
||||
*
|
||||
* Or on the command line during compile:
|
||||
*
|
||||
* cc -DSHA2_USE_INTTYPES_H ...
|
||||
*/
|
||||
#ifdef SHA2_USE_INTTYPES_H
|
||||
|
||||
typedef struct _SHA256_CTX {
|
||||
uint32_t state[8];
|
||||
uint64_t bitcount;
|
||||
uint8_t buffer[SHA256_BLOCK_LENGTH];
|
||||
} SHA256_CTX;
|
||||
typedef struct _SHA512_CTX {
|
||||
uint64_t state[8];
|
||||
uint64_t bitcount[2];
|
||||
uint8_t buffer[SHA512_BLOCK_LENGTH];
|
||||
} SHA512_CTX;
|
||||
|
||||
#else /* SHA2_USE_INTTYPES_H */
|
||||
|
||||
typedef struct _SHA256_CTX {
|
||||
u_int32_t state[8];
|
||||
u_int64_t bitcount;
|
||||
u_int8_t buffer[SHA256_BLOCK_LENGTH];
|
||||
} SHA256_CTX;
|
||||
typedef struct _SHA512_CTX {
|
||||
u_int64_t state[8];
|
||||
u_int64_t bitcount[2];
|
||||
u_int8_t buffer[SHA512_BLOCK_LENGTH];
|
||||
} SHA512_CTX;
|
||||
|
||||
#endif /* SHA2_USE_INTTYPES_H */
|
||||
|
||||
typedef SHA512_CTX SHA384_CTX;
|
||||
|
||||
|
||||
/*** SHA-256/384/512 Function Prototypes ******************************/
|
||||
#ifndef NOPROTO
|
||||
#ifdef SHA2_USE_INTTYPES_H
|
||||
|
||||
void SHA256_Init(SHA256_CTX *);
|
||||
void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t);
|
||||
void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
|
||||
char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||
char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||
|
||||
void SHA384_Init(SHA384_CTX*);
|
||||
void SHA384_Update(SHA384_CTX*, const uint8_t*, size_t);
|
||||
void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
|
||||
char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||
char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||
|
||||
void SHA512_Init(SHA512_CTX*);
|
||||
void SHA512_Update(SHA512_CTX*, const uint8_t*, size_t);
|
||||
void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
|
||||
char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||
char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||
|
||||
#else /* SHA2_USE_INTTYPES_H */
|
||||
|
||||
void SHA256_Init(SHA256_CTX *);
|
||||
void SHA256_Update(SHA256_CTX*, const u_int8_t*, size_t);
|
||||
void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
|
||||
char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||
char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||
|
||||
void SHA384_Init(SHA384_CTX*);
|
||||
void SHA384_Update(SHA384_CTX*, const u_int8_t*, size_t);
|
||||
void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
|
||||
char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||
char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||
|
||||
void SHA512_Init(SHA512_CTX*);
|
||||
void SHA512_Update(SHA512_CTX*, const u_int8_t*, size_t);
|
||||
void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
|
||||
char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||
char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||
|
||||
#endif /* SHA2_USE_INTTYPES_H */
|
||||
|
||||
#else /* NOPROTO */
|
||||
|
||||
void SHA256_Init();
|
||||
void SHA256_Update();
|
||||
void SHA256_Final();
|
||||
char* SHA256_End();
|
||||
char* SHA256_Data();
|
||||
|
||||
void SHA384_Init();
|
||||
void SHA384_Update();
|
||||
void SHA384_Final();
|
||||
char* SHA384_End();
|
||||
char* SHA384_Data();
|
||||
|
||||
void SHA512_Init();
|
||||
void SHA512_Update();
|
||||
void SHA512_Final();
|
||||
char* SHA512_End();
|
||||
char* SHA512_Data();
|
||||
|
||||
#endif /* NOPROTO */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __SHA2_H__ */
|
||||
|
||||
@@ -12,6 +12,7 @@ SET ( TESTS_SRCS
|
||||
EventBaseTests.cc
|
||||
PhysicsTests.cc
|
||||
ControllerBaseTests.cc
|
||||
UtilsTests.cc
|
||||
)
|
||||
|
||||
FIND_PACKAGE (UnitTest++)
|
||||
|
||||
Reference in New Issue
Block a user