GetPlugin should be extern "C".

[stg.git] / stglibs / crypto.lib / blowfish.c

diff --git a/stglibs/crypto.lib/blowfish.c b/stglibs/crypto.lib/blowfish.c
index e11bb1a27f0e9ad692fa82735b59b55cc9b032cd..e2f275e6275b0322bab7536093245fdb263e6143 100644 (file)
--- a/stglibs/crypto.lib/blowfish.c
+++ b/stglibs/crypto.lib/blowfish.c
@@ -8,7 +8,7 @@
 #include <string.h>
 
 #include "stg/const.h"
 #include <string.h>
 
 #include "stg/const.h"

-#include "blowfish.h"
+#include "stg/blowfish.h"

 
 #define ENCRYPT 0
 #define DECRYPT 1
 
 #define ENCRYPT 0
 #define DECRYPT 1


@@ -16,6 +16,8 @@
 #define endianBig ((unsigned char) 0x45)
 #define endianLittle ((unsigned char) 0x54)
 
 #define endianBig ((unsigned char) 0x45)
 #define endianLittle ((unsigned char) 0x54)
 

+#define MIN(a,b) ((a) < (b) ? a : b)
+

 #ifdef WIN32 /* Win32 doesn't have random() or lstat */
     #define random() rand()
     #define initstate(x,y,z) srand(x)
 #ifdef WIN32 /* Win32 doesn't have random() or lstat */
     #define random() rand()
     #define initstate(x,y,z) srand(x)


@@ -27,9 +29,9 @@
 #endif
 
 
 #endif
 
 

-#define N               16
+#define N 16

 
 

-static uint32_t F(BLOWFISH_CTX *ctx, uint32_t x);
+static uint32_t F(const BLOWFISH_CTX *ctx, uint32_t x);

 static const uint32_t ORIG_P[16 + 2] = {
 0x243F6A88L, 0x85A308D3L, 0x13198A2EL, 0x03707344L,
 0xA4093822L, 0x299F31D0L, 0x082EFA98L, 0xEC4E6C89L,
 static const uint32_t ORIG_P[16 + 2] = {
 0x243F6A88L, 0x85A308D3L, 0x13198A2EL, 0x03707344L,
 0xA4093822L, 0x299F31D0L, 0x082EFA98L, 0xEC4E6C89L,


@@ -300,7 +302,7 @@ static const uint32_t ORIG_S[4][256] = {
     0xB74E6132L, 0xCE77E25BL, 0x578FDFE3L, 0x3AC372E6L}
 };
 //-----------------------------------------------------------------------------
     0xB74E6132L, 0xCE77E25BL, 0x578FDFE3L, 0x3AC372E6L}
 };
 //-----------------------------------------------------------------------------

-uint32_t F(BLOWFISH_CTX *ctx, uint32_t x) 
+uint32_t F(const BLOWFISH_CTX *ctx, uint32_t x) 

 {
 unsigned short a, b, c, d;
 uint32_t  y = 0;
 {
 unsigned short a, b, c, d;
 uint32_t  y = 0;


@@ -324,7 +326,7 @@ y = y + ctx->S[3][d];
 return y;
 }
 //-----------------------------------------------------------------------------
 return y;
 }
 //-----------------------------------------------------------------------------

-void Blowfish_Encrypt(BLOWFISH_CTX *ctx, uint32_t *xl, uint32_t *xr)
+void Blowfish_Encrypt(const BLOWFISH_CTX *ctx, uint32_t *xl, uint32_t *xr)

 {
 uint32_t  Xl;
 uint32_t  Xr;
 {
 uint32_t  Xl;
 uint32_t  Xr;


@@ -352,7 +354,7 @@ Xl = Xl ^ ctx->P[N + 1];
 *xr = Xr;
 }
 //-----------------------------------------------------------------------------
 *xr = Xr;
 }
 //-----------------------------------------------------------------------------

-void Blowfish_Decrypt(BLOWFISH_CTX *ctx, uint32_t *xl, uint32_t *xr)
+void Blowfish_Decrypt(const BLOWFISH_CTX *ctx, uint32_t *xl, uint32_t *xr)

 {
 uint32_t  Xl;
 uint32_t  Xr;
 {
 uint32_t  Xl;
 uint32_t  Xr;


@@ -435,13 +437,13 @@ for (i = 0; i < 4; ++i)
     }
 }
 //-----------------------------------------------------------------------------
     }
 }
 //-----------------------------------------------------------------------------

-void EnDecodeInit(const char * passwd, int length, BLOWFISH_CTX *ctx)
+void InitContext(const char * passwd, size_t length, BLOWFISH_CTX * ctx)

 {
 unsigned char keyL[PASSWD_LEN];
 
 memset(keyL, 0, PASSWD_LEN);
 
 {
 unsigned char keyL[PASSWD_LEN];
 
 memset(keyL, 0, PASSWD_LEN);
 

-strncpy((char *)keyL, passwd, PASSWD_LEN);
+strncpy((char *)keyL, passwd, MIN(length, PASSWD_LEN));

 
 Blowfish_Init(ctx, keyL, PASSWD_LEN);
 }
 
 Blowfish_Init(ctx, keyL, PASSWD_LEN);
 }


@@ -465,7 +467,7 @@ void block2bytes(uint32_t t, char * c)
     *c = t >> 24 & 0x000000FF;
 }
 //-----------------------------------------------------------------------------
     *c = t >> 24 & 0x000000FF;
 }
 //-----------------------------------------------------------------------------

-void DecodeString(char * d, const char * s, BLOWFISH_CTX *ctx)
+void DecryptBlock(void * d, const void * s, const BLOWFISH_CTX *ctx)

 {
 uint32_t a = bytes2block(s);
 uint32_t b = bytes2block(s + 4);
 {
 uint32_t a = bytes2block(s);
 uint32_t b = bytes2block(s + 4);


@@ -476,7 +478,7 @@ block2bytes(a, d);
 block2bytes(b, d + 4);
 }
 //-----------------------------------------------------------------------------
 block2bytes(b, d + 4);
 }
 //-----------------------------------------------------------------------------

-void EncodeString(char * d, const char * s, BLOWFISH_CTX *ctx)
+void EncryptBlock(void * d, const void * s, const BLOWFISH_CTX *ctx)

 {
 uint32_t a = bytes2block(s);
 uint32_t b = bytes2block(s + 4);
 {
 uint32_t a = bytes2block(s);
 uint32_t b = bytes2block(s + 4);


@@ -487,3 +489,32 @@ block2bytes(a, d);
 block2bytes(b, d + 4);
 }
 //-----------------------------------------------------------------------------
 block2bytes(b, d + 4);
 }
 //-----------------------------------------------------------------------------

+void DecryptString(void * d, const void * s, size_t length, const BLOWFISH_CTX * ctx)
+{
+size_t pos = 0;
+while (pos < length)
+    {
+    DecryptBlock(d + pos, s + pos, ctx);
+    pos += 8;
+    }
+}
+//-----------------------------------------------------------------------------
+void EncryptString(void * d, const void * s, size_t length, const BLOWFISH_CTX * ctx)
+{
+size_t pos = 0;
+while (pos < length)
+    {
+    if (pos + 8 < length)
+        EncryptBlock(d + pos, s + pos, ctx);
+    else
+        {
+        // Short string, use 0-padded buffer.
+        char buf[8];
+        memset(buf, 0, sizeof(buf));
+        memcpy(buf, s + pos, length - pos);
+        EncryptBlock(d + pos, buf, ctx);
+        }
+    pos += 8;
+    }
+}
+//-----------------------------------------------------------------------------