diff options
| author |   Unit 193 <unit193@ubuntu.com> | 2017-02-09 04:36:04 -0500 |
|---|---|---|
| committer | Unit 193 <unit193@ubuntu.com> | 2017-02-09 04:36:04 -0500 |
| commit | d9aa870e5d509cc7309ab82dd102a937ab58613a (patch) | |
| tree | d92d03d76b5c390b335f1cfd761f1a0b59ec8496 /Plugins/DbSqliteWx/rijndael.h | |
| parent | 68ee4cbcbe424b95969c70346283a9f217f63825 (diff) | |
Imported Upstream version 3.1.1+dfsg1upstream/3.1.1+dfsg1
Diffstat (limited to 'Plugins/DbSqliteWx/rijndael.h')
| -rw-r--r-- | Plugins/DbSqliteWx/rijndael.h | 194 |
1 files changed, 194 insertions, 0 deletions
diff --git a/Plugins/DbSqliteWx/rijndael.h b/Plugins/DbSqliteWx/rijndael.h new file mode 100644 index 0000000..ce72566 --- /dev/null +++ b/Plugins/DbSqliteWx/rijndael.h @@ -0,0 +1,194 @@ +/*
+///////////////////////////////////////////////////////////////////////////////
+// Name: rijndael.h
+// Purpose:
+// Author: Ulrich Telle
+// Modified by:
+// Created: 2006-12-06
+// Copyright: (c) Ulrich Telle (Copyright for original code see below)
+// Licence: wxWindows licence
+//
+// The original code is unchanged
+///////////////////////////////////////////////////////////////////////////////
+
+/// \file rijndael.h Interface of the Rijndael cipher
+*/
+
+#ifndef _RIJNDAEL_H_
+#define _RIJNDAEL_H_
+
+/*
+// File : rijndael.h
+// Creation date : Sun Nov 5 2000 03:21:05 CEST
+// Author : Szymon Stefanek (stefanek@tin.it)
+//
+// Another implementation of the Rijndael cipher.
+// This is intended to be an easily usable library file.
+// This code is public domain.
+// Based on the Vincent Rijmen and K.U.Leuven implementation 2.4.
+//
+// Original Copyright notice:
+//
+// rijndael-alg-fst.c v2.4 April '2000
+// rijndael-alg-fst.h
+// rijndael-api-fst.c
+// rijndael-api-fst.h
+//
+// Optimised ANSI C code
+//
+// authors: v1.0: Antoon Bosselaers
+// v2.0: Vincent Rijmen, K.U.Leuven
+// v2.3: Paulo Barreto
+// v2.4: Vincent Rijmen, K.U.Leuven
+//
+// This code is placed in the public domain.
+//
+
+//
+// This implementation works on 128 , 192 , 256 bit keys
+// and on 128 bit blocks
+//
+
+//
+// Example of usage:
+//
+// // Input data
+// unsigned char key[32]; // The key
+// initializeYour256BitKey(); // Obviously initialized with sth
+// const unsigned char * plainText = getYourPlainText(); // Your plain text
+// int plainTextLen = strlen(plainText); // Plain text length
+//
+// // Encrypting
+// Rijndael rin;
+// unsigned char output[plainTextLen + 16];
+//
+// rin.init(Rijndael::CBC,Rijndael::Encrypt,key,Rijndael::Key32Bytes);
+// // It is a good idea to check the error code
+// int len = rin.padEncrypt(plainText,len,output);
+// if(len >= 0)useYourEncryptedText();
+// else encryptError(len);
+//
+// // Decrypting: we can reuse the same object
+// unsigned char output2[len];
+// rin.init(Rijndael::CBC,Rijndael::Decrypt,key,Rijndael::Key32Bytes));
+// len = rin.padDecrypt(output,len,output2);
+// if(len >= 0)useYourDecryptedText();
+// else decryptError(len);
+//
+*/
+
+#define _MAX_KEY_COLUMNS (256/32)
+#define _MAX_ROUNDS 14
+#define MAX_IV_SIZE 16
+
+/* We assume that unsigned int is 32 bits long.... */
+typedef unsigned char UINT8;
+typedef unsigned int UINT32;
+typedef unsigned short UINT16;
+
+/* Error codes */
+#define RIJNDAEL_SUCCESS 0
+#define RIJNDAEL_UNSUPPORTED_MODE -1
+#define RIJNDAEL_UNSUPPORTED_DIRECTION -2
+#define RIJNDAEL_UNSUPPORTED_KEY_LENGTH -3
+#define RIJNDAEL_BAD_KEY -4
+#define RIJNDAEL_NOT_INITIALIZED -5
+#define RIJNDAEL_BAD_DIRECTION -6
+#define RIJNDAEL_CORRUPTED_DATA -7
+
+#define RIJNDAEL_Direction_Encrypt 0
+#define RIJNDAEL_Direction_Decrypt 1
+
+#define RIJNDAEL_Direction_Mode_ECB 0
+#define RIJNDAEL_Direction_Mode_CBC 1
+#define RIJNDAEL_Direction_Mode_CFB1 2
+
+#define RIJNDAEL_Direction_KeyLength_Key16Bytes 0
+#define RIJNDAEL_Direction_KeyLength_Key24Bytes 1
+#define RIJNDAEL_Direction_KeyLength_Key32Bytes 2
+
+#define RIJNDAEL_State_Valid 0
+#define RIJNDAEL_State_Invalid 1
+
+/*
+/// Class implementing the Rijndael cipher. (For internal use only)
+*/
+
+typedef struct _Rijndael
+{
+ int m_state;
+ int m_mode;
+ int m_direction;
+ UINT8 m_initVector[MAX_IV_SIZE];
+ UINT32 m_uRounds;
+ UINT8 m_expandedKey[_MAX_ROUNDS+1][4][4];
+} Rijndael;
+
+void RijndaelCreate(Rijndael* rijndael);
+
+/*
+//////////////////////////////////////////////////////////////////////////////////////////
+// API
+//////////////////////////////////////////////////////////////////////////////////////////
+
+// init(): Initializes the crypt session
+// Returns RIJNDAEL_SUCCESS or an error code
+// mode : Rijndael::ECB, Rijndael::CBC or Rijndael::CFB1
+// You have to use the same mode for encrypting and decrypting
+// dir : Rijndael::Encrypt or Rijndael::Decrypt
+// A cipher instance works only in one direction
+// (Well , it could be easily modified to work in both
+// directions with a single init() call, but it looks
+// useless to me...anyway , it is a matter of generating
+// two expanded keys)
+// key : array of unsigned octets , it can be 16 , 24 or 32 bytes long
+// this CAN be binary data (it is not expected to be null terminated)
+// keyLen : Rijndael::Key16Bytes , Rijndael::Key24Bytes or Rijndael::Key32Bytes
+// initVector: initialization vector, you will usually use 0 here
+*/
+int RijndaelInit(Rijndael* rijndael, int mode, int dir, UINT8* key, int keyLen, UINT8* initVector);
+
+/*
+// Encrypts the input array (can be binary data)
+// The input array length must be a multiple of 16 bytes, the remaining part
+// is DISCARDED.
+// so it actually encrypts inputLen / 128 blocks of input and puts it in outBuffer
+// Input len is in BITS!
+// outBuffer must be at least inputLen / 8 bytes long.
+// Returns the encrypted buffer length in BITS or an error code < 0 in case of error
+*/
+int RijndaelBlockEncrypt(Rijndael* rijndael, UINT8 *input, int inputLen, UINT8 *outBuffer);
+
+/*
+// Encrypts the input array (can be binary data)
+// The input array can be any length , it is automatically padded on a 16 byte boundary.
+// Input len is in BYTES!
+// outBuffer must be at least (inputLen + 16) bytes long
+// Returns the encrypted buffer length in BYTES or an error code < 0 in case of error
+*/
+int RijndaelPadEncrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8 *outBuffer);
+
+/*
+// Decrypts the input vector
+// Input len is in BITS!
+// outBuffer must be at least inputLen / 8 bytes long
+// Returns the decrypted buffer length in BITS and an error code < 0 in case of error
+*/
+int RijndaelBlockDecrypt(Rijndael* rijndael, UINT8 *input, int inputLen, UINT8 *outBuffer);
+
+/*
+// Decrypts the input vector
+// Input len is in BYTES!
+// outBuffer must be at least inputLen bytes long
+// Returns the decrypted buffer length in BYTES and an error code < 0 in case of error
+*/
+int RijndaelPadDecrypt(Rijndael* rijndael, UINT8 *input, int inputOctets, UINT8 *outBuffer);
+
+void RijndaelInvalidate(Rijndael* rijndael);
+void RijndaelKeySched(Rijndael* rijndael, UINT8 key[_MAX_KEY_COLUMNS][4]);
+void RijndaelKeyEncToDec(Rijndael* rijndael);
+void RijndaelEncrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16]);
+void RijndaelDecrypt(Rijndael* rijndael, UINT8 a[16], UINT8 b[16]);
+
+#endif /* _RIJNDAEL_H_ */
+
|