forked from metin2/server
Added support for CLion, removed a lot of unused code in preparation of the rewriting of the network stack
This commit is contained in:
@ -1,23 +0,0 @@
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* TEA is a 64-bit symmetric block cipher with a 128-bit key, developed
|
||||
by David J. Wheeler and Roger M. Needham, and described in their
|
||||
paper at <URL:http://www.cl.cam.ac.uk/ftp/users/djw3/tea.ps>.
|
||||
|
||||
This implementation is based on their code in
|
||||
<URL:http://www.cl.cam.ac.uk/ftp/users/djw3/xtea.ps> */
|
||||
|
||||
extern int TEA_Encrypt(DWORD *dest, const DWORD *src, const DWORD *key, int size);
|
||||
extern int TEA_Decrypt(DWORD *dest, const DWORD *src, const DWORD *key, int size);
|
||||
|
||||
extern int GOST_Encrypt(DWORD * DstBuffer, const DWORD * SrcBuffer, const DWORD * KeyAddress, DWORD Length, DWORD *IVector);
|
||||
extern int GOST_Decrypt(DWORD * DstBuffer, const DWORD * SrcBuffer, const DWORD * KeyAddress, DWORD Length, DWORD *IVector);
|
||||
|
||||
extern int DES_Encrypt(DWORD *DstBuffer, const DWORD * SrcBuffer, const DWORD *KeyAddress, DWORD Length, DWORD *IVector);
|
||||
extern int DES_Decrypt(DWORD *DstBuffer, const DWORD * SrcBuffer, const DWORD *KeyAddress, DWORD Length, DWORD *IVector);
|
||||
|
||||
#ifdef __cplusplus
|
||||
};
|
||||
#endif
|
||||
@ -1,31 +0,0 @@
|
||||
#ifndef __INC_LIBTHECORE_HANGUL_H__
|
||||
#define __INC_LIBTHECORE_HANGUL_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifdef __WIN32__
|
||||
#define isdigit iswdigit
|
||||
#define isspace iswspace
|
||||
#endif
|
||||
|
||||
#define ishan(ch) (((ch) & 0xE0) > 0x90)
|
||||
#define ishanasc(ch) (isascii(ch) || ishan(ch))
|
||||
#define ishanalp(ch) (isalpha(ch) || ishan(ch))
|
||||
#define isnhdigit(ch) (!ishan(ch) && isdigit(ch))
|
||||
#define isnhspace(ch) (!ishan(ch) && isspace(ch))
|
||||
|
||||
extern const char * first_han(const BYTE * str); // ù<><C3B9>° <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)<29><> <20>̾<EFBFBD> <20><>/<2F><>/<2F><>/..<2E><> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
|
||||
extern int check_han(const char * str); // <20>ѱ<EFBFBD><D1B1≯<EFBFBD> true <20><>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD> üũ
|
||||
extern int is_hangul(const BYTE * str); // <20>ѱ<EFBFBD><D1B1≯<EFBFBD> true (2<><32><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> üũ)
|
||||
extern int under_han(const void * orig); // <20><>ħ<EFBFBD><C4A7> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true
|
||||
|
||||
#define UNDER(str) under_han(str)
|
||||
|
||||
#ifdef __cplusplus
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -1,10 +0,0 @@
|
||||
/*
|
||||
* Filename: kstbl.h
|
||||
* Description: KS <20>ϼ<EFBFBD><CFBC><EFBFBD> 2350<35><30><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ<EFBFBD>
|
||||
*
|
||||
* Author: <20><><EFBFBD><EFBFBD> (server), myevan (Client)
|
||||
*/
|
||||
#ifndef __KSTBL_H__
|
||||
#define __KSTBL_H__
|
||||
extern unsigned KStbl[2350];
|
||||
#endif
|
||||
@ -1,23 +0,0 @@
|
||||
#ifndef __INC_LIBTHECORE_MEMCPY_H__
|
||||
#define __INC_LIBTHECORE_MEMCPY_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
#ifdef __LIBTHECORE__
|
||||
void thecore_find_best_memcpy();
|
||||
#endif
|
||||
|
||||
#ifndef __WIN32__
|
||||
extern void *(*thecore_memcpy) (void * to, const void * from, size_t len);
|
||||
#else
|
||||
#include <cstring>
|
||||
#define thecore_memcpy memcpy
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -132,14 +132,10 @@ inline double rint(double x)
|
||||
#include "heart.h"
|
||||
#include "fdwatch.h"
|
||||
#include "socket.h"
|
||||
#include "kstbl.h"
|
||||
#include "hangul.h"
|
||||
#include "buffer.h"
|
||||
#include "signal.h"
|
||||
#include "log.h"
|
||||
#include "main.h"
|
||||
#include "utils.h"
|
||||
#include "crypt.h"
|
||||
#include "memcpy.h"
|
||||
|
||||
#endif // __INC_LIBTHECORE_STDAFX_H__
|
||||
|
||||
@ -1,82 +0,0 @@
|
||||
#ifndef __FreeBSD__
|
||||
|
||||
/*
|
||||
* luau (Lib Update/Auto-Update): Simple Update Library
|
||||
* Copyright (C) 2003 David Eklund
|
||||
*
|
||||
* - This library is free software; you can redistribute it and/or -
|
||||
* - modify it under the terms of the GNU Lesser General Public -
|
||||
* - License as published by the Free Software Foundation; either -
|
||||
* - version 2.1 of the License, or (at your option) any later version. -
|
||||
* - -
|
||||
* - This library is distributed in the hope that it will be useful, -
|
||||
* - but WITHOUT ANY WARRANTY; without even the implied warranty of -
|
||||
* - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -
|
||||
* - Lesser General Public License for more details. -
|
||||
* - -
|
||||
* - You should have received a copy of the GNU Lesser General Public -
|
||||
* - License along with this library; if not, write to the Free Software -
|
||||
* - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -
|
||||
*/
|
||||
|
||||
/*
|
||||
* md5.h and md5.c are based off of md5hl.c, md5c.c, and md5.h from libmd, which in turn are
|
||||
* based off the FreeBSD libmd library. Their respective copyright notices follow:
|
||||
*/
|
||||
|
||||
/*
|
||||
* This code implements the MD5 message-digest algorithm.
|
||||
* The algorithm is due to Ron Rivest. This code was
|
||||
* written by Colin Plumb in 1993, no copyright is claimed.
|
||||
* This code is in the public domain; do with it what you wish.
|
||||
*
|
||||
* Equivalent code is available from RSA Data Security, Inc.
|
||||
* This code has been tested against that, and is equivalent,
|
||||
* except that you don't need to include two pages of legalese
|
||||
* with every copy.
|
||||
*/
|
||||
|
||||
/* ----------------------------------------------------------------------------
|
||||
* "THE BEER-WARE LICENSE" (Revision 42):
|
||||
* <phk@login.dkuug.dk> wrote this file. As long as you retain this notice you
|
||||
* can do whatever you want with this stuff. If we meet some day, and you think
|
||||
* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
|
||||
* ----------------------------------------------------------------------------
|
||||
*
|
||||
* $Id: md5.h,v 1.1.1.1 2004/04/02 05:11:38 deklund2 Exp $
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MD5_H
|
||||
#define MD5_H
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
#define MD5_HASHBYTES 16
|
||||
|
||||
typedef struct MD5Context {
|
||||
uint32_t buf[4];
|
||||
uint32_t bits[2];
|
||||
unsigned char in[64];
|
||||
} MD5_CTX;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void MD5Init(MD5_CTX *context);
|
||||
void MD5Update(MD5_CTX *context, unsigned char const *buf, unsigned len);
|
||||
void MD5Final(unsigned char digest[MD5_HASHBYTES], MD5_CTX *context);
|
||||
void MD5Transform(uint32_t buf[4], uint32_t const in[16]);
|
||||
char* MD5End(MD5_CTX *, char *);
|
||||
|
||||
char* lutil_md5_file(const char *filename, char *buf);
|
||||
char* lutil_md5_data(const unsigned char *data, unsigned int len, char *buf);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* MD5_H */
|
||||
|
||||
#endif // #ifndef __FreeBSD__
|
||||
@ -1,326 +0,0 @@
|
||||
static DWORD SP_boxes[8][64]=
|
||||
{
|
||||
/* 0 */
|
||||
{
|
||||
0x00820200, 0x00020000, 0x80800000, 0x80820200,
|
||||
0x00800000, 0x80020200, 0x80020000, 0x80800000,
|
||||
0x80020200, 0x00820200, 0x00820000, 0x80000200,
|
||||
0x80800200, 0x00800000, 0x00000000, 0x80020000,
|
||||
0x00020000, 0x80000000, 0x00800200, 0x00020200,
|
||||
0x80820200, 0x00820000, 0x80000200, 0x00800200,
|
||||
0x80000000, 0x00000200, 0x00020200, 0x80820000,
|
||||
0x00000200, 0x80800200, 0x80820000, 0x00000000,
|
||||
0x00000000, 0x80820200, 0x00800200, 0x80020000,
|
||||
0x00820200, 0x00020000, 0x80000200, 0x00800200,
|
||||
0x80820000, 0x00000200, 0x00020200, 0x80800000,
|
||||
0x80020200, 0x80000000, 0x80800000, 0x00820000,
|
||||
0x80820200, 0x00020200, 0x00820000, 0x80800200,
|
||||
0x00800000, 0x80000200, 0x80020000, 0x00000000,
|
||||
0x00020000, 0x00800000, 0x80800200, 0x00820200,
|
||||
0x80000000, 0x80820000, 0x00000200, 0x80020200
|
||||
},
|
||||
|
||||
/* 1 */
|
||||
{
|
||||
0x10042004, 0x00000000, 0x00042000, 0x10040000,
|
||||
0x10000004, 0x00002004, 0x10002000, 0x00042000,
|
||||
0x00002000, 0x10040004, 0x00000004, 0x10002000,
|
||||
0x00040004, 0x10042000, 0x10040000, 0x00000004,
|
||||
0x00040000, 0x10002004, 0x10040004, 0x00002000,
|
||||
0x00042004, 0x10000000, 0x00000000, 0x00040004,
|
||||
0x10002004, 0x00042004, 0x10042000, 0x10000004,
|
||||
0x10000000, 0x00040000, 0x00002004, 0x10042004,
|
||||
0x00040004, 0x10042000, 0x10002000, 0x00042004,
|
||||
0x10042004, 0x00040004, 0x10000004, 0x00000000,
|
||||
0x10000000, 0x00002004, 0x00040000, 0x10040004,
|
||||
0x00002000, 0x10000000, 0x00042004, 0x10002004,
|
||||
0x10042000, 0x00002000, 0x00000000, 0x10000004,
|
||||
0x00000004, 0x10042004, 0x00042000, 0x10040000,
|
||||
0x10040004, 0x00040000, 0x00002004, 0x10002000,
|
||||
0x10002004, 0x00000004, 0x10040000, 0x00042000
|
||||
},
|
||||
|
||||
/* 2 */
|
||||
{
|
||||
0x41000000, 0x01010040, 0x00000040, 0x41000040,
|
||||
0x40010000, 0x01000000, 0x41000040, 0x00010040,
|
||||
0x01000040, 0x00010000, 0x01010000, 0x40000000,
|
||||
0x41010040, 0x40000040, 0x40000000, 0x41010000,
|
||||
0x00000000, 0x40010000, 0x01010040, 0x00000040,
|
||||
0x40000040, 0x41010040, 0x00010000, 0x41000000,
|
||||
0x41010000, 0x01000040, 0x40010040, 0x01010000,
|
||||
0x00010040, 0x00000000, 0x01000000, 0x40010040,
|
||||
0x01010040, 0x00000040, 0x40000000, 0x00010000,
|
||||
0x40000040, 0x40010000, 0x01010000, 0x41000040,
|
||||
0x00000000, 0x01010040, 0x00010040, 0x41010000,
|
||||
0x40010000, 0x01000000, 0x41010040, 0x40000000,
|
||||
0x40010040, 0x41000000, 0x01000000, 0x41010040,
|
||||
0x00010000, 0x01000040, 0x41000040, 0x00010040,
|
||||
0x01000040, 0x00000000, 0x41010000, 0x40000040,
|
||||
0x41000000, 0x40010040, 0x00000040, 0x01010000
|
||||
},
|
||||
|
||||
/* 3 */
|
||||
{
|
||||
0x00100402, 0x04000400, 0x00000002, 0x04100402,
|
||||
0x00000000, 0x04100000, 0x04000402, 0x00100002,
|
||||
0x04100400, 0x04000002, 0x04000000, 0x00000402,
|
||||
0x04000002, 0x00100402, 0x00100000, 0x04000000,
|
||||
0x04100002, 0x00100400, 0x00000400, 0x00000002,
|
||||
0x00100400, 0x04000402, 0x04100000, 0x00000400,
|
||||
0x00000402, 0x00000000, 0x00100002, 0x04100400,
|
||||
0x04000400, 0x04100002, 0x04100402, 0x00100000,
|
||||
0x04100002, 0x00000402, 0x00100000, 0x04000002,
|
||||
0x00100400, 0x04000400, 0x00000002, 0x04100000,
|
||||
0x04000402, 0x00000000, 0x00000400, 0x00100002,
|
||||
0x00000000, 0x04100002, 0x04100400, 0x00000400,
|
||||
0x04000000, 0x04100402, 0x00100402, 0x00100000,
|
||||
0x04100402, 0x00000002, 0x04000400, 0x00100402,
|
||||
0x00100002, 0x00100400, 0x04100000, 0x04000402,
|
||||
0x00000402, 0x04000000, 0x04000002, 0x04100400
|
||||
},
|
||||
|
||||
/* 4 */
|
||||
{
|
||||
0x02000000, 0x00004000, 0x00000100, 0x02004108,
|
||||
0x02004008, 0x02000100, 0x00004108, 0x02004000,
|
||||
0x00004000, 0x00000008, 0x02000008, 0x00004100,
|
||||
0x02000108, 0x02004008, 0x02004100, 0x00000000,
|
||||
0x00004100, 0x02000000, 0x00004008, 0x00000108,
|
||||
0x02000100, 0x00004108, 0x00000000, 0x02000008,
|
||||
0x00000008, 0x02000108, 0x02004108, 0x00004008,
|
||||
0x02004000, 0x00000100, 0x00000108, 0x02004100,
|
||||
0x02004100, 0x02000108, 0x00004008, 0x02004000,
|
||||
0x00004000, 0x00000008, 0x02000008, 0x02000100,
|
||||
0x02000000, 0x00004100, 0x02004108, 0x00000000,
|
||||
0x00004108, 0x02000000, 0x00000100, 0x00004008,
|
||||
0x02000108, 0x00000100, 0x00000000, 0x02004108,
|
||||
0x02004008, 0x02004100, 0x00000108, 0x00004000,
|
||||
0x00004100, 0x02004008, 0x02000100, 0x00000108,
|
||||
0x00000008, 0x00004108, 0x02004000, 0x02000008
|
||||
},
|
||||
|
||||
/* 5 */
|
||||
{
|
||||
0x20000010, 0x00080010, 0x00000000, 0x20080800,
|
||||
0x00080010, 0x00000800, 0x20000810, 0x00080000,
|
||||
0x00000810, 0x20080810, 0x00080800, 0x20000000,
|
||||
0x20000800, 0x20000010, 0x20080000, 0x00080810,
|
||||
0x00080000, 0x20000810, 0x20080010, 0x00000000,
|
||||
0x00000800, 0x00000010, 0x20080800, 0x20080010,
|
||||
0x20080810, 0x20080000, 0x20000000, 0x00000810,
|
||||
0x00000010, 0x00080800, 0x00080810, 0x20000800,
|
||||
0x00000810, 0x20000000, 0x20000800, 0x00080810,
|
||||
0x20080800, 0x00080010, 0x00000000, 0x20000800,
|
||||
0x20000000, 0x00000800, 0x20080010, 0x00080000,
|
||||
0x00080010, 0x20080810, 0x00080800, 0x00000010,
|
||||
0x20080810, 0x00080800, 0x00080000, 0x20000810,
|
||||
0x20000010, 0x20080000, 0x00080810, 0x00000000,
|
||||
0x00000800, 0x20000010, 0x20000810, 0x20080800,
|
||||
0x20080000, 0x00000810, 0x00000010, 0x20080010
|
||||
},
|
||||
|
||||
/* 6 */
|
||||
{
|
||||
0x00001000, 0x00000080, 0x00400080, 0x00400001,
|
||||
0x00401081, 0x00001001, 0x00001080, 0x00000000,
|
||||
0x00400000, 0x00400081, 0x00000081, 0x00401000,
|
||||
0x00000001, 0x00401080, 0x00401000, 0x00000081,
|
||||
0x00400081, 0x00001000, 0x00001001, 0x00401081,
|
||||
0x00000000, 0x00400080, 0x00400001, 0x00001080,
|
||||
0x00401001, 0x00001081, 0x00401080, 0x00000001,
|
||||
0x00001081, 0x00401001, 0x00000080, 0x00400000,
|
||||
0x00001081, 0x00401000, 0x00401001, 0x00000081,
|
||||
0x00001000, 0x00000080, 0x00400000, 0x00401001,
|
||||
0x00400081, 0x00001081, 0x00001080, 0x00000000,
|
||||
0x00000080, 0x00400001, 0x00000001, 0x00400080,
|
||||
0x00000000, 0x00400081, 0x00400080, 0x00001080,
|
||||
0x00000081, 0x00001000, 0x00401081, 0x00400000,
|
||||
0x00401080, 0x00000001, 0x00001001, 0x00401081,
|
||||
0x00400001, 0x00401080, 0x00401000, 0x00001001
|
||||
},
|
||||
|
||||
/* 7 */
|
||||
{
|
||||
0x08200020, 0x08208000, 0x00008020, 0x00000000,
|
||||
0x08008000, 0x00200020, 0x08200000, 0x08208020,
|
||||
0x00000020, 0x08000000, 0x00208000, 0x00008020,
|
||||
0x00208020, 0x08008020, 0x08000020, 0x08200000,
|
||||
0x00008000, 0x00208020, 0x00200020, 0x08008000,
|
||||
0x08208020, 0x08000020, 0x00000000, 0x00208000,
|
||||
0x08000000, 0x00200000, 0x08008020, 0x08200020,
|
||||
0x00200000, 0x00008000, 0x08208000, 0x00000020,
|
||||
0x00200000, 0x00008000, 0x08000020, 0x08208020,
|
||||
0x00008020, 0x08000000, 0x00000000, 0x00208000,
|
||||
0x08200020, 0x08008020, 0x08008000, 0x00200020,
|
||||
0x08208000, 0x00000020, 0x00200020, 0x08008000,
|
||||
0x08208020, 0x00200000, 0x08200000, 0x08000020,
|
||||
0x00208000, 0x00008020, 0x08008020, 0x08200000,
|
||||
0x00000020, 0x08208000, 0x00208020, 0x00000000,
|
||||
0x08000000, 0x08200020, 0x00008000, 0x00208020
|
||||
}
|
||||
};
|
||||
|
||||
static DWORD KeyPerm[8][64] =
|
||||
{
|
||||
/* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
|
||||
{
|
||||
0x00000000,0x00000010,0x20000000,0x20000010,
|
||||
0x00010000,0x00010010,0x20010000,0x20010010,
|
||||
0x00000800,0x00000810,0x20000800,0x20000810,
|
||||
0x00010800,0x00010810,0x20010800,0x20010810,
|
||||
0x00000020,0x00000030,0x20000020,0x20000030,
|
||||
0x00010020,0x00010030,0x20010020,0x20010030,
|
||||
0x00000820,0x00000830,0x20000820,0x20000830,
|
||||
0x00010820,0x00010830,0x20010820,0x20010830,
|
||||
0x00080000,0x00080010,0x20080000,0x20080010,
|
||||
0x00090000,0x00090010,0x20090000,0x20090010,
|
||||
0x00080800,0x00080810,0x20080800,0x20080810,
|
||||
0x00090800,0x00090810,0x20090800,0x20090810,
|
||||
0x00080020,0x00080030,0x20080020,0x20080030,
|
||||
0x00090020,0x00090030,0x20090020,0x20090030,
|
||||
0x00080820,0x00080830,0x20080820,0x20080830,
|
||||
0x00090820,0x00090830,0x20090820,0x20090830
|
||||
},
|
||||
|
||||
/* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
|
||||
{
|
||||
0x00000000,0x02000000,0x00002000,0x02002000,
|
||||
0x00200000,0x02200000,0x00202000,0x02202000,
|
||||
0x00000004,0x02000004,0x00002004,0x02002004,
|
||||
0x00200004,0x02200004,0x00202004,0x02202004,
|
||||
0x00000400,0x02000400,0x00002400,0x02002400,
|
||||
0x00200400,0x02200400,0x00202400,0x02202400,
|
||||
0x00000404,0x02000404,0x00002404,0x02002404,
|
||||
0x00200404,0x02200404,0x00202404,0x02202404,
|
||||
0x10000000,0x12000000,0x10002000,0x12002000,
|
||||
0x10200000,0x12200000,0x10202000,0x12202000,
|
||||
0x10000004,0x12000004,0x10002004,0x12002004,
|
||||
0x10200004,0x12200004,0x10202004,0x12202004,
|
||||
0x10000400,0x12000400,0x10002400,0x12002400,
|
||||
0x10200400,0x12200400,0x10202400,0x12202400,
|
||||
0x10000404,0x12000404,0x10002404,0x12002404,
|
||||
0x10200404,0x12200404,0x10202404,0x12202404
|
||||
},
|
||||
|
||||
/* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
|
||||
{
|
||||
0x00000000,0x00000001,0x00040000,0x00040001,
|
||||
0x01000000,0x01000001,0x01040000,0x01040001,
|
||||
0x00000002,0x00000003,0x00040002,0x00040003,
|
||||
0x01000002,0x01000003,0x01040002,0x01040003,
|
||||
0x00000200,0x00000201,0x00040200,0x00040201,
|
||||
0x01000200,0x01000201,0x01040200,0x01040201,
|
||||
0x00000202,0x00000203,0x00040202,0x00040203,
|
||||
0x01000202,0x01000203,0x01040202,0x01040203,
|
||||
0x08000000,0x08000001,0x08040000,0x08040001,
|
||||
0x09000000,0x09000001,0x09040000,0x09040001,
|
||||
0x08000002,0x08000003,0x08040002,0x08040003,
|
||||
0x09000002,0x09000003,0x09040002,0x09040003,
|
||||
0x08000200,0x08000201,0x08040200,0x08040201,
|
||||
0x09000200,0x09000201,0x09040200,0x09040201,
|
||||
0x08000202,0x08000203,0x08040202,0x08040203,
|
||||
0x09000202,0x09000203,0x09040202,0x09040203
|
||||
},
|
||||
|
||||
/* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
|
||||
{
|
||||
0x00000000,0x00100000,0x00000100,0x00100100,
|
||||
0x00000008,0x00100008,0x00000108,0x00100108,
|
||||
0x00001000,0x00101000,0x00001100,0x00101100,
|
||||
0x00001008,0x00101008,0x00001108,0x00101108,
|
||||
0x04000000,0x04100000,0x04000100,0x04100100,
|
||||
0x04000008,0x04100008,0x04000108,0x04100108,
|
||||
0x04001000,0x04101000,0x04001100,0x04101100,
|
||||
0x04001008,0x04101008,0x04001108,0x04101108,
|
||||
0x00020000,0x00120000,0x00020100,0x00120100,
|
||||
0x00020008,0x00120008,0x00020108,0x00120108,
|
||||
0x00021000,0x00121000,0x00021100,0x00121100,
|
||||
0x00021008,0x00121008,0x00021108,0x00121108,
|
||||
0x04020000,0x04120000,0x04020100,0x04120100,
|
||||
0x04020008,0x04120008,0x04020108,0x04120108,
|
||||
0x04021000,0x04121000,0x04021100,0x04121100,
|
||||
0x04021008,0x04121008,0x04021108,0x04121108
|
||||
},
|
||||
|
||||
/* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
|
||||
{
|
||||
0x00000000,0x10000000,0x00010000,0x10010000,
|
||||
0x00000004,0x10000004,0x00010004,0x10010004,
|
||||
0x20000000,0x30000000,0x20010000,0x30010000,
|
||||
0x20000004,0x30000004,0x20010004,0x30010004,
|
||||
0x00100000,0x10100000,0x00110000,0x10110000,
|
||||
0x00100004,0x10100004,0x00110004,0x10110004,
|
||||
0x20100000,0x30100000,0x20110000,0x30110000,
|
||||
0x20100004,0x30100004,0x20110004,0x30110004,
|
||||
0x00001000,0x10001000,0x00011000,0x10011000,
|
||||
0x00001004,0x10001004,0x00011004,0x10011004,
|
||||
0x20001000,0x30001000,0x20011000,0x30011000,
|
||||
0x20001004,0x30001004,0x20011004,0x30011004,
|
||||
0x00101000,0x10101000,0x00111000,0x10111000,
|
||||
0x00101004,0x10101004,0x00111004,0x10111004,
|
||||
0x20101000,0x30101000,0x20111000,0x30111000,
|
||||
0x20101004,0x30101004,0x20111004,0x30111004
|
||||
},
|
||||
|
||||
/* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
|
||||
{
|
||||
0x00000000,0x08000000,0x00000008,0x08000008,
|
||||
0x00000400,0x08000400,0x00000408,0x08000408,
|
||||
0x00020000,0x08020000,0x00020008,0x08020008,
|
||||
0x00020400,0x08020400,0x00020408,0x08020408,
|
||||
0x00000001,0x08000001,0x00000009,0x08000009,
|
||||
0x00000401,0x08000401,0x00000409,0x08000409,
|
||||
0x00020001,0x08020001,0x00020009,0x08020009,
|
||||
0x00020401,0x08020401,0x00020409,0x08020409,
|
||||
0x02000000,0x0A000000,0x02000008,0x0A000008,
|
||||
0x02000400,0x0A000400,0x02000408,0x0A000408,
|
||||
0x02020000,0x0A020000,0x02020008,0x0A020008,
|
||||
0x02020400,0x0A020400,0x02020408,0x0A020408,
|
||||
0x02000001,0x0A000001,0x02000009,0x0A000009,
|
||||
0x02000401,0x0A000401,0x02000409,0x0A000409,
|
||||
0x02020001,0x0A020001,0x02020009,0x0A020009,
|
||||
0x02020401,0x0A020401,0x02020409,0x0A020409
|
||||
},
|
||||
|
||||
/* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
|
||||
{
|
||||
0x00000000,0x00000100,0x00080000,0x00080100,
|
||||
0x01000000,0x01000100,0x01080000,0x01080100,
|
||||
0x00000010,0x00000110,0x00080010,0x00080110,
|
||||
0x01000010,0x01000110,0x01080010,0x01080110,
|
||||
0x00200000,0x00200100,0x00280000,0x00280100,
|
||||
0x01200000,0x01200100,0x01280000,0x01280100,
|
||||
0x00200010,0x00200110,0x00280010,0x00280110,
|
||||
0x01200010,0x01200110,0x01280010,0x01280110,
|
||||
0x00000200,0x00000300,0x00080200,0x00080300,
|
||||
0x01000200,0x01000300,0x01080200,0x01080300,
|
||||
0x00000210,0x00000310,0x00080210,0x00080310,
|
||||
0x01000210,0x01000310,0x01080210,0x01080310,
|
||||
0x00200200,0x00200300,0x00280200,0x00280300,
|
||||
0x01200200,0x01200300,0x01280200,0x01280300,
|
||||
0x00200210,0x00200310,0x00280210,0x00280310,
|
||||
0x01200210,0x01200310,0x01280210,0x01280310
|
||||
},
|
||||
|
||||
/* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
|
||||
{
|
||||
0x00000000,0x04000000,0x00040000,0x04040000,
|
||||
0x00000002,0x04000002,0x00040002,0x04040002,
|
||||
0x00002000,0x04002000,0x00042000,0x04042000,
|
||||
0x00002002,0x04002002,0x00042002,0x04042002,
|
||||
0x00000020,0x04000020,0x00040020,0x04040020,
|
||||
0x00000022,0x04000022,0x00040022,0x04040022,
|
||||
0x00002020,0x04002020,0x00042020,0x04042020,
|
||||
0x00002022,0x04002022,0x00042022,0x04042022,
|
||||
0x00000800,0x04000800,0x00040800,0x04040800,
|
||||
0x00000802,0x04000802,0x00040802,0x04040802,
|
||||
0x00002800,0x04002800,0x00042800,0x04042800,
|
||||
0x00002802,0x04002802,0x00042802,0x04042802,
|
||||
0x00000820,0x04000820,0x00040820,0x04040820,
|
||||
0x00000822,0x04000822,0x00040822,0x04040822,
|
||||
0x00002820,0x04002820,0x00042820,0x04042820,
|
||||
0x00002822,0x04002822,0x00042822,0x04042822
|
||||
}
|
||||
};
|
||||
|
||||
@ -164,13 +164,13 @@ void buffer_write(LPBUFFER& buffer, const void *src, int length)
|
||||
if (buffer->write_point_pos + length >= buffer->mem_size)
|
||||
buffer_realloc(buffer, buffer->mem_size + length + MIN(10240, length));
|
||||
|
||||
thecore_memcpy(buffer->write_point, src, length);
|
||||
memcpy(buffer->write_point, src, length);
|
||||
buffer_write_proceed(buffer, length);
|
||||
}
|
||||
|
||||
void buffer_read(LPBUFFER buffer, void * buf, int bytes)
|
||||
{
|
||||
thecore_memcpy(buf, buffer->read_point, bytes);
|
||||
memcpy(buf, buffer->read_point, bytes);
|
||||
buffer_read_proceed(buffer, bytes);
|
||||
}
|
||||
|
||||
@ -277,7 +277,7 @@ void buffer_realloc(LPBUFFER& buffer, int length)
|
||||
|
||||
temp = buffer_new (length);
|
||||
sys_log(0, "reallocating buffer to %d, current %d", temp->mem_size, buffer->mem_size);
|
||||
thecore_memcpy(temp->mem_data, buffer->mem_data, buffer->mem_size);
|
||||
memcpy(temp->mem_data, buffer->mem_data, buffer->mem_size);
|
||||
|
||||
read_point_pos = buffer->read_point - buffer->mem_data;
|
||||
|
||||
|
||||
@ -1,281 +0,0 @@
|
||||
#include "stdafx.h"
|
||||
#include "DES_table.h"
|
||||
|
||||
#define DES_ECB_ENCRYPT 0
|
||||
#define DES_ECB_DECRYPT 1
|
||||
|
||||
// DES ECB encryption code
|
||||
extern DWORD SP_boxes[8][64];
|
||||
//extern DWORD KeyPerm[8][64];
|
||||
|
||||
/*
|
||||
* Macroses to transform array of 4 bytes to 32-bit dwords
|
||||
* (and reverse) without depending on the Little-Endian or
|
||||
* Big-Endian processor's architecture
|
||||
*/
|
||||
#define BYTES_TO_DWORD(b,d) (d = ((DWORD)(*((b)++))), \
|
||||
d |= ((DWORD)(*((b)++)))<< 8, \
|
||||
d |= ((DWORD)(*((b)++)))<<16, \
|
||||
d |= ((DWORD)(*((b)++)))<<24)
|
||||
|
||||
#define DWORD_TO_4BYTES(d,b) (*((b)++)=(BYTE)(((d) )&0xff), \
|
||||
*((b)++)=(BYTE)(((d)>> 8)&0xff), \
|
||||
*((b)++)=(BYTE)(((d)>>16)&0xff), \
|
||||
*((b)++)=(BYTE)(((d)>>24)&0xff))
|
||||
|
||||
/*
|
||||
* First of all, take into accounts the bytes and bites ordering
|
||||
* used in DES:
|
||||
*
|
||||
* DES: 1 2 3 4 5 6 7 8 .... 57 58 59 60 61 62 63 64
|
||||
* INTEL: 63 62 61 60 59 58 57 56 .... 7 6 5 4 3 2 1 0
|
||||
*
|
||||
* According to the DES, every 8-th bits is not used:
|
||||
* for DES the bites 8, 16, 32, ..., 64 are excluded,
|
||||
* for INTEL: 56, 48, 40, ..., 0 are excluded
|
||||
*
|
||||
* According to the above rool of numbering, the tables
|
||||
* used in DES (for Initial Permutation, Final Permutation,
|
||||
* Key Permutation, Compression Permutation, Expansion
|
||||
* Permutation and P-Box permutation) have to be re-written.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
Some main ideas used to optimize DES software
|
||||
implementation:
|
||||
|
||||
a). Do not make an Expansion Permutation of 32-bit to
|
||||
48 bit (32-bit of data - right half of 64-bit of data),
|
||||
but make a correspondent preparation of the Key. So,
|
||||
the step of Expansion Permutation and XORing 48 bit of
|
||||
Expanded data and 48 bit of Compressed key will be
|
||||
replaced by 2 XOR operations: 32 bit of data XOR first
|
||||
32 bit part of prepeared key, then, the same 32 bit of
|
||||
data XOR second 32-bit part of prepeared key
|
||||
|
||||
b). Combine S-Box Substitution and P-Box Permutation
|
||||
operations.
|
||||
|
||||
c). For the best performance 56-bit encryption key
|
||||
have to be extendended to 128-byte array, i.e. for each
|
||||
of 16 rounds of DES we prepare a unique pair of two
|
||||
32-bit (4-bytes) words (see 'a)' above).
|
||||
|
||||
d). We can use XOR, SHIFT, AND operations to swap
|
||||
bits between words. For example, we have:
|
||||
|
||||
word A word B
|
||||
0 1 2 3 4 5 6 7
|
||||
|
||||
We want to get:
|
||||
|
||||
word A word B
|
||||
0 4 2 6 1 5 3 7
|
||||
|
||||
First, shift word A to get bites 1, 3 on the "right place"
|
||||
|
||||
word TMP = (word A) >> 1 = 1 2 3 -
|
||||
|
||||
TMP = TMP ^ B = 1^4 2^5 3^6 7
|
||||
|
||||
we don't want to change bits 5 and 7 in the B word, so
|
||||
|
||||
TMP = TMP & MASK = TMP & 1010 = 1^4 - 3^6 -
|
||||
|
||||
now we can easy get the word B:
|
||||
|
||||
B = B ^ TMP = (4 5 6 7) ^ (1^4 - 3^6 -) = 1 5 3 7
|
||||
|
||||
if we shift our "masking" TMP word reverse - we get
|
||||
a mask for A word:
|
||||
|
||||
TMP = TMP << 1 = - 1^4 - 3^6
|
||||
|
||||
now we can easy get the word A:
|
||||
|
||||
A = A ^ TMP = (0 1 2 3) ^ (- 1^4 - 3^6) = 0 4 2 6
|
||||
|
||||
The example above may be used to swap not only single
|
||||
bits, but also bit sequencies. In this case you should
|
||||
use shift on the value, equal to the number of bits
|
||||
in pattern.
|
||||
|
||||
As you see, all this opearations may be written like:
|
||||
TMP = ((A >> size) ^ B) & mask;
|
||||
B ^ = TMP;
|
||||
A ^= TMP << size;
|
||||
*/
|
||||
|
||||
#define PERMUTATION(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
|
||||
(b)^=(t),\
|
||||
(a)^=((t)<<(n)))
|
||||
|
||||
#define HPERMUTATION(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
|
||||
(a)=(a)^(t)^(t>>(16-(n))))
|
||||
|
||||
#define D_ENCRYPT(Left, Right, Ks, Num, TmpA, TmpB) \
|
||||
TmpA = (Right ^ Ks[Num ]); \
|
||||
TmpB = (Right ^ Ks[Num+1]); \
|
||||
TmpB = ((TmpB >> 4) + (TmpB << 28)); \
|
||||
Left ^= SP_boxes[1][(TmpB )&0x3f]| \
|
||||
SP_boxes[3][(TmpB>> 8)&0x3f]| \
|
||||
SP_boxes[5][(TmpB>>16)&0x3f]| \
|
||||
SP_boxes[7][(TmpB>>24)&0x3f]| \
|
||||
SP_boxes[0][(TmpA )&0x3f]| \
|
||||
SP_boxes[2][(TmpA>> 8)&0x3f]| \
|
||||
SP_boxes[4][(TmpA>>16)&0x3f]| \
|
||||
SP_boxes[6][(TmpA>>24)&0x3f];
|
||||
|
||||
void DES_ECB_mode(BYTE * Input, /* 8 bytes of input data */
|
||||
BYTE * Output, /* 8 bytes of output data */
|
||||
const DWORD * KeySchedule, /* [16][2] array of DWORDs */
|
||||
BYTE Operation) /* DES_ECB_ENCRYPT or DES_ECB_DECRYPT */
|
||||
{
|
||||
static BYTE * bInp, * bOut;
|
||||
static DWORD dwLeft, dwRigh, dwTmp, dwTmp1;
|
||||
|
||||
bInp = Input;
|
||||
bOut = Output;
|
||||
|
||||
BYTES_TO_DWORD(bInp, dwLeft);
|
||||
BYTES_TO_DWORD(bInp, dwRigh);
|
||||
|
||||
/* Initial Permutation */
|
||||
PERMUTATION(dwRigh, dwLeft, dwTmp, 4, 0x0f0f0f0f);
|
||||
PERMUTATION(dwLeft, dwRigh, dwTmp,16, 0x0000ffff);
|
||||
PERMUTATION(dwRigh, dwLeft, dwTmp, 2, 0x33333333);
|
||||
PERMUTATION(dwLeft, dwRigh, dwTmp, 8, 0x00ff00ff);
|
||||
PERMUTATION(dwRigh, dwLeft, dwTmp, 1, 0x55555555);
|
||||
|
||||
/* dwRigh and dwLeft has reversed bit orders - itwill be taken
|
||||
into account in the next step */
|
||||
|
||||
/* The initial rotate is done outside the loop. This required the
|
||||
* SP_boxes values to be rotated 1 bit to the right.
|
||||
*/
|
||||
dwTmp = (dwRigh<<1) | (dwRigh>>31);
|
||||
dwRigh = (dwLeft<<1) | (dwLeft>>31);
|
||||
dwLeft = dwTmp;
|
||||
|
||||
/* clear the top bits on machines with 8byte longs */
|
||||
dwLeft &= 0xffffffff;
|
||||
dwRigh &= 0xffffffff;
|
||||
|
||||
if (Operation == DES_ECB_ENCRYPT)
|
||||
{ /* Key order */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 0, dwTmp, dwTmp1); /* 1 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 2, dwTmp, dwTmp1); /* 2 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 4, dwTmp, dwTmp1); /* 3 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 6, dwTmp, dwTmp1); /* 4 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 8, dwTmp, dwTmp1); /* 5 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 10, dwTmp, dwTmp1); /* 6 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 12, dwTmp, dwTmp1); /* 7 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 14, dwTmp, dwTmp1); /* 8 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 16, dwTmp, dwTmp1); /* 9 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 18, dwTmp, dwTmp1); /* 10 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 20, dwTmp, dwTmp1); /* 11 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 22, dwTmp, dwTmp1); /* 12 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 24, dwTmp, dwTmp1); /* 13 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 26, dwTmp, dwTmp1); /* 14 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 28, dwTmp, dwTmp1); /* 15 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 30, dwTmp, dwTmp1); /* 16 */
|
||||
}
|
||||
else
|
||||
{
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 30, dwTmp, dwTmp1); /* 16 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 28, dwTmp, dwTmp1); /* 15 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 26, dwTmp, dwTmp1); /* 14 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 24, dwTmp, dwTmp1); /* 13 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 22, dwTmp, dwTmp1); /* 12 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 20, dwTmp, dwTmp1); /* 11 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 18, dwTmp, dwTmp1); /* 10 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 16, dwTmp, dwTmp1); /* 9 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 14, dwTmp, dwTmp1); /* 8 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 12, dwTmp, dwTmp1); /* 7 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 10, dwTmp, dwTmp1); /* 6 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 8, dwTmp, dwTmp1); /* 5 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 6, dwTmp, dwTmp1); /* 4 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 4, dwTmp, dwTmp1); /* 3 */
|
||||
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 2, dwTmp, dwTmp1); /* 2 */
|
||||
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 0, dwTmp, dwTmp1); /* 1 */
|
||||
}
|
||||
|
||||
dwLeft = (dwLeft>>1) | (dwLeft<<31);
|
||||
dwRigh = (dwRigh>>1) | (dwRigh<<31);
|
||||
|
||||
/* clear the top bits on machines with 8byte longs */
|
||||
dwLeft &= 0xffffffff;
|
||||
dwRigh &= 0xffffffff;
|
||||
|
||||
/*
|
||||
* Do we need to swap dwLeft and dwRigh?
|
||||
* We have not to do the swap
|
||||
* (We remember they are reversed)
|
||||
* So - all we have to do is to make a correspondent Final Permutation
|
||||
*/
|
||||
|
||||
PERMUTATION(dwRigh, dwLeft, dwTmp, 1,0x55555555);
|
||||
PERMUTATION(dwLeft, dwRigh, dwTmp, 8,0x00ff00ff);
|
||||
PERMUTATION(dwRigh, dwLeft, dwTmp, 2,0x33333333);
|
||||
PERMUTATION(dwLeft, dwRigh, dwTmp,16,0x0000ffff);
|
||||
PERMUTATION(dwRigh, dwLeft, dwTmp, 4,0x0f0f0f0f);
|
||||
|
||||
/* Place our two 32-bits results into 8 bytes of output data */
|
||||
DWORD_TO_4BYTES(dwLeft, bOut);
|
||||
DWORD_TO_4BYTES(dwRigh, bOut);
|
||||
}
|
||||
|
||||
//************ DES CBC mode encryption **************
|
||||
int DES_Encrypt(DWORD *DstBuffer, const DWORD * SrcBuffer, const DWORD *KeyAddress, DWORD Length, DWORD *IVector)
|
||||
{
|
||||
DWORD i;
|
||||
DWORD buffer[2];
|
||||
|
||||
buffer[0] = IVector[0];
|
||||
buffer[1] = IVector[1];
|
||||
|
||||
for (i = 0; i < (Length >> 2); i = i+2)
|
||||
{
|
||||
// do EBC encryption of (Initial_Vector XOR Data)
|
||||
buffer[0] ^= SrcBuffer[i];
|
||||
buffer[1] ^= SrcBuffer[i+1];
|
||||
|
||||
DES_ECB_mode((BYTE *) buffer, (BYTE *) buffer, KeyAddress, DES_ECB_ENCRYPT);
|
||||
|
||||
DstBuffer[i] = buffer[0];
|
||||
DstBuffer[i+1] = buffer[1];
|
||||
}
|
||||
|
||||
return Length;
|
||||
}
|
||||
|
||||
//************ DES CBC mode decryption **************
|
||||
int DES_Decrypt(DWORD *DstBuffer, const DWORD * SrcBuffer, const DWORD *KeyAddress, DWORD Length, DWORD *IVector)
|
||||
{
|
||||
DWORD i;
|
||||
DWORD buffer[2], ivectorL, ivectorR, oldSrcL, oldSrcR;
|
||||
|
||||
ivectorL = IVector[0];
|
||||
ivectorR = IVector[1];
|
||||
|
||||
for (i = 0; i < (Length >> 2); i = i + 2)
|
||||
{
|
||||
buffer[0] = oldSrcL = SrcBuffer[i];
|
||||
buffer[1] = oldSrcR = SrcBuffer[i+1];
|
||||
|
||||
// Encrypted Data -> new IV,
|
||||
// then do EBC decryption of Encrypted Data,
|
||||
// then XOR decrypted data with old IV
|
||||
DES_ECB_mode((BYTE *)buffer, (BYTE *)buffer, KeyAddress, DES_ECB_DECRYPT);
|
||||
|
||||
DstBuffer[i] = buffer[0] ^ ivectorL;
|
||||
DstBuffer[i+1] = buffer[1] ^ ivectorR;
|
||||
|
||||
ivectorL = oldSrcL;
|
||||
ivectorR = oldSrcR;
|
||||
}
|
||||
|
||||
return Length;
|
||||
}
|
||||
|
||||
@ -1,234 +0,0 @@
|
||||
#include "stdafx.h"
|
||||
/*
|
||||
static unsigned char const k8[16] = { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 };
|
||||
static unsigned char const k7[16] = { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 };
|
||||
static unsigned char const k6[16] = { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 };
|
||||
static unsigned char const k5[16] = { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 };
|
||||
static unsigned char const k4[16] = { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 };
|
||||
static unsigned char const k3[16] = { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 };
|
||||
static unsigned char const k2[16] = { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 };
|
||||
static unsigned char const k1[16] = { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 };
|
||||
*/
|
||||
static unsigned char const k8[16] = { 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 };
|
||||
static unsigned char const k7[16] = { 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 };
|
||||
static unsigned char const k6[16] = { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 };
|
||||
static unsigned char const k5[16] = { 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 };
|
||||
static unsigned char const k4[16] = { 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 };
|
||||
static unsigned char const k3[16] = { 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 };
|
||||
static unsigned char const k2[16] = { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 };
|
||||
static unsigned char const k1[16] = { 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 };
|
||||
|
||||
/* Byte-at-a-time substitution boxes */
|
||||
static unsigned char k87[256];
|
||||
static unsigned char k65[256];
|
||||
static unsigned char k43[256];
|
||||
static unsigned char k21[256];
|
||||
|
||||
void GOST_Init()
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
k87[i] = k8[i >> 4] << 4 | k7[i & 15];
|
||||
k65[i] = k6[i >> 4] << 4 | k5[i & 15];
|
||||
k43[i] = k4[i >> 4] << 4 | k3[i & 15];
|
||||
k21[i] = k2[i >> 4] << 4 | k1[i & 15];
|
||||
}
|
||||
}
|
||||
|
||||
INLINE static DWORD f(DWORD x)
|
||||
{
|
||||
x = k87[x >> 24 & 255] << 24 | k65[x >> 16 & 255] << 16 | k43[x >> 8 & 255] << 8 | k21[x & 255];
|
||||
return x << 11 | x >> (32 - 11);
|
||||
}
|
||||
/*
|
||||
static void GOST_ECB_Encrypt(DWORD * N1, DWORD * N2, const DWORD * KeyAddress)
|
||||
{
|
||||
register DWORD n1, n2; // As named in the GOST
|
||||
|
||||
n1 = *N1;
|
||||
n2 = *N2;
|
||||
|
||||
// Instead of swapping halves, swap names each round
|
||||
n2 ^= f(n1+KeyAddress[0]);
|
||||
n1 ^= f(n2+KeyAddress[1]);
|
||||
n2 ^= f(n1+KeyAddress[2]);
|
||||
n1 ^= f(n2+KeyAddress[3]);
|
||||
n2 ^= f(n1+KeyAddress[4]);
|
||||
n1 ^= f(n2+KeyAddress[5]);
|
||||
n2 ^= f(n1+KeyAddress[6]);
|
||||
n1 ^= f(n2+KeyAddress[7]);
|
||||
|
||||
n2 ^= f(n1+KeyAddress[0]);
|
||||
n1 ^= f(n2+KeyAddress[1]);
|
||||
n2 ^= f(n1+KeyAddress[2]);
|
||||
n1 ^= f(n2+KeyAddress[3]);
|
||||
n2 ^= f(n1+KeyAddress[4]);
|
||||
n1 ^= f(n2+KeyAddress[5]);
|
||||
n2 ^= f(n1+KeyAddress[6]);
|
||||
n1 ^= f(n2+KeyAddress[7]);
|
||||
|
||||
n2 ^= f(n1+KeyAddress[0]);
|
||||
n1 ^= f(n2+KeyAddress[1]);
|
||||
n2 ^= f(n1+KeyAddress[2]);
|
||||
n1 ^= f(n2+KeyAddress[3]);
|
||||
n2 ^= f(n1+KeyAddress[4]);
|
||||
n1 ^= f(n2+KeyAddress[5]);
|
||||
n2 ^= f(n1+KeyAddress[6]);
|
||||
n1 ^= f(n2+KeyAddress[7]);
|
||||
|
||||
n2 ^= f(n1+KeyAddress[7]);
|
||||
n1 ^= f(n2+KeyAddress[6]);
|
||||
n2 ^= f(n1+KeyAddress[5]);
|
||||
n1 ^= f(n2+KeyAddress[4]);
|
||||
n2 ^= f(n1+KeyAddress[3]);
|
||||
n1 ^= f(n2+KeyAddress[2]);
|
||||
n2 ^= f(n1+KeyAddress[1]);
|
||||
n1 ^= f(n2+KeyAddress[0]);
|
||||
|
||||
// There is no swap after the last round
|
||||
*N1 = n2;
|
||||
*N2 = n1;
|
||||
}
|
||||
*/
|
||||
int GOST_Encrypt(DWORD * DstBuffer, const DWORD * SrcBuffer, const DWORD * KeyAddress, DWORD Length, DWORD *IVector)
|
||||
{
|
||||
DWORD i;
|
||||
DWORD N1,N2;
|
||||
|
||||
N1 = IVector[0];
|
||||
N2 = IVector[1];
|
||||
|
||||
for (i = 0; i < (Length >> 2); i = i+2)
|
||||
{
|
||||
register DWORD n1, n2; // As named in the GOST
|
||||
|
||||
n1 = N1;
|
||||
n2 = N2;
|
||||
|
||||
// Instead of swapping halves, swap names each round
|
||||
n2 ^= f(n1+KeyAddress[0]);
|
||||
n1 ^= f(n2+KeyAddress[1]);
|
||||
n2 ^= f(n1+KeyAddress[2]);
|
||||
n1 ^= f(n2+KeyAddress[3]);
|
||||
n2 ^= f(n1+KeyAddress[4]);
|
||||
n1 ^= f(n2+KeyAddress[5]);
|
||||
n2 ^= f(n1+KeyAddress[6]);
|
||||
n1 ^= f(n2+KeyAddress[7]);
|
||||
|
||||
n2 ^= f(n1+KeyAddress[0]);
|
||||
n1 ^= f(n2+KeyAddress[1]);
|
||||
n2 ^= f(n1+KeyAddress[2]);
|
||||
n1 ^= f(n2+KeyAddress[3]);
|
||||
n2 ^= f(n1+KeyAddress[4]);
|
||||
n1 ^= f(n2+KeyAddress[5]);
|
||||
n2 ^= f(n1+KeyAddress[6]);
|
||||
n1 ^= f(n2+KeyAddress[7]);
|
||||
|
||||
n2 ^= f(n1+KeyAddress[0]);
|
||||
n1 ^= f(n2+KeyAddress[1]);
|
||||
n2 ^= f(n1+KeyAddress[2]);
|
||||
n1 ^= f(n2+KeyAddress[3]);
|
||||
n2 ^= f(n1+KeyAddress[4]);
|
||||
n1 ^= f(n2+KeyAddress[5]);
|
||||
n2 ^= f(n1+KeyAddress[6]);
|
||||
n1 ^= f(n2+KeyAddress[7]);
|
||||
|
||||
n2 ^= f(n1+KeyAddress[7]);
|
||||
n1 ^= f(n2+KeyAddress[6]);
|
||||
n2 ^= f(n1+KeyAddress[5]);
|
||||
n1 ^= f(n2+KeyAddress[4]);
|
||||
n2 ^= f(n1+KeyAddress[3]);
|
||||
n1 ^= f(n2+KeyAddress[2]);
|
||||
n2 ^= f(n1+KeyAddress[1]);
|
||||
n1 ^= f(n2+KeyAddress[0]);
|
||||
|
||||
N1 = n2;
|
||||
N2 = n1;
|
||||
//GOST_ECB_Encrypt(&N1, &N2, KeyAddress);
|
||||
// XOR plaintext with initial vector,
|
||||
// move rezult to ciphertext and to initial vector
|
||||
DstBuffer[i] = SrcBuffer[i] ^ N1;
|
||||
N1 = DstBuffer[i];
|
||||
|
||||
DstBuffer[i+1] = SrcBuffer[i+1] ^ N2;
|
||||
N2 = DstBuffer[i+1];
|
||||
}
|
||||
|
||||
return Length;
|
||||
}
|
||||
|
||||
|
||||
// ************ GOST CBC decryption **************
|
||||
int GOST_Decrypt(DWORD * DstBuffer, const DWORD * SrcBuffer, const DWORD * KeyAddress, DWORD Length, DWORD *IVector)
|
||||
{
|
||||
DWORD i;
|
||||
DWORD N1, N2, dwTmp;
|
||||
|
||||
N1 = IVector[0];
|
||||
N2 = IVector[1];
|
||||
|
||||
for (i = 0; i < (Length >> 2); i = i + 2)
|
||||
{
|
||||
register DWORD n1, n2; // As named in the GOST
|
||||
|
||||
n1 = N1;
|
||||
n2 = N2;
|
||||
|
||||
// Instead of swapping halves, swap names each round
|
||||
n2 ^= f(n1+KeyAddress[0]);
|
||||
n1 ^= f(n2+KeyAddress[1]);
|
||||
n2 ^= f(n1+KeyAddress[2]);
|
||||
n1 ^= f(n2+KeyAddress[3]);
|
||||
n2 ^= f(n1+KeyAddress[4]);
|
||||
n1 ^= f(n2+KeyAddress[5]);
|
||||
n2 ^= f(n1+KeyAddress[6]);
|
||||
n1 ^= f(n2+KeyAddress[7]);
|
||||
|
||||
n2 ^= f(n1+KeyAddress[0]);
|
||||
n1 ^= f(n2+KeyAddress[1]);
|
||||
n2 ^= f(n1+KeyAddress[2]);
|
||||
n1 ^= f(n2+KeyAddress[3]);
|
||||
n2 ^= f(n1+KeyAddress[4]);
|
||||
n1 ^= f(n2+KeyAddress[5]);
|
||||
n2 ^= f(n1+KeyAddress[6]);
|
||||
n1 ^= f(n2+KeyAddress[7]);
|
||||
|
||||
n2 ^= f(n1+KeyAddress[0]);
|
||||
n1 ^= f(n2+KeyAddress[1]);
|
||||
n2 ^= f(n1+KeyAddress[2]);
|
||||
n1 ^= f(n2+KeyAddress[3]);
|
||||
n2 ^= f(n1+KeyAddress[4]);
|
||||
n1 ^= f(n2+KeyAddress[5]);
|
||||
n2 ^= f(n1+KeyAddress[6]);
|
||||
n1 ^= f(n2+KeyAddress[7]);
|
||||
|
||||
n2 ^= f(n1+KeyAddress[7]);
|
||||
n1 ^= f(n2+KeyAddress[6]);
|
||||
n2 ^= f(n1+KeyAddress[5]);
|
||||
n1 ^= f(n2+KeyAddress[4]);
|
||||
n2 ^= f(n1+KeyAddress[3]);
|
||||
n1 ^= f(n2+KeyAddress[2]);
|
||||
n2 ^= f(n1+KeyAddress[1]);
|
||||
n1 ^= f(n2+KeyAddress[0]);
|
||||
|
||||
// There is no swap after the last round
|
||||
N1 = n2;
|
||||
N2 = n1;
|
||||
//GOST_ECB_Encrypt(&N1, &N2, KeyAddress);
|
||||
// XOR encrypted text with encrypted initial vector (we get rezult - decrypted text),
|
||||
// move encrypted text to new initial vector.
|
||||
// We need dwTmp because SrcBuffer may be the same as DstBuffer
|
||||
dwTmp = SrcBuffer[i] ^ N1;
|
||||
N1 = SrcBuffer[i];
|
||||
DstBuffer[i] = dwTmp;
|
||||
|
||||
dwTmp = SrcBuffer[i+1] ^ N2;
|
||||
N2 = SrcBuffer[i+1];
|
||||
DstBuffer[i+1] = dwTmp;
|
||||
}
|
||||
|
||||
return Length;
|
||||
}
|
||||
|
||||
@ -1,411 +0,0 @@
|
||||
/*
|
||||
* The GOST 28147-89 cipher
|
||||
*
|
||||
* This is based on the 25 Movember 1993 draft translation
|
||||
* by Aleksandr Malchik, with Whitfield Diffie, of the Government
|
||||
* Standard of the U.S.S.R. GOST 28149-89, "Cryptographic Transformation
|
||||
* Algorithm", effective 1 July 1990. (Whitfield.Diffie@eng.sun.com)
|
||||
*
|
||||
* That is a draft, and may contain errors, which will be faithfully
|
||||
* reflected here, along with possible exciting new bugs.
|
||||
*
|
||||
* Some details have been cleared up by the paper "Soviet Encryption
|
||||
* Algorithm" by Josef Pieprzyk and Leonid Tombak of the University
|
||||
* of Wollongong, New South Wales. (josef/leo@cs.adfa.oz.au)
|
||||
*
|
||||
* The standard is written by A. Zabotin (project leader), G.P. Glazkov,
|
||||
* and V.B. Isaeva. It was accepted and introduced into use by the
|
||||
* action of the State Standards Committee of the USSR on 2 June 89 as
|
||||
* No. 1409. It was to be reviewed in 1993, but whether anyone wishes
|
||||
* to take on this obligation from the USSR is questionable.
|
||||
*
|
||||
* This code is placed in the public domain.
|
||||
*/
|
||||
|
||||
/*
|
||||
* If you read the standard, it belabors the point of copying corresponding
|
||||
* bits from point A to point B quite a bit. It helps to understand that
|
||||
* the standard is uniformly little-endian, although it numbers bits from
|
||||
* 1 rather than 0, so bit n has value 2^(n-1). The least significant bit
|
||||
* of the 32-bit words that are manipulated in the algorithm is the first,
|
||||
* lowest-numbered, in the bit string.
|
||||
*/
|
||||
|
||||
|
||||
/* A 32-bit data type */
|
||||
#ifdef __alpha /* Any other 64-bit machines? */
|
||||
typedef unsigned int word32;
|
||||
#else
|
||||
typedef unsigned long word32;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* The standard does not specify the contents of the 8 4 bit->4 bit
|
||||
* substitution boxes, saying they're a parameter of the network
|
||||
* being set up. For illustration purposes here, I have used
|
||||
* the first rows of the 8 S-boxes from the DES. (Note that the
|
||||
* DES S-boxes are numbered starting from 1 at the msb. In keeping
|
||||
* with the rest of the GOST, I have used little-endian numbering.
|
||||
* Thus, k8 is S-box 1.
|
||||
*
|
||||
* Obviously, a careful look at the cryptographic properties of the cipher
|
||||
* must be undertaken before "production" substitution boxes are defined.
|
||||
*
|
||||
* The standard also does not specify a standard bit-string representation
|
||||
* for the contents of these blocks.
|
||||
*/
|
||||
static unsigned char const k8[16] = { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 };
|
||||
static unsigned char const k7[16] = { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 };
|
||||
static unsigned char const k6[16] = { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 };
|
||||
static unsigned char const k5[16] = { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 };
|
||||
static unsigned char const k4[16] = { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 };
|
||||
static unsigned char const k3[16] = { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 };
|
||||
static unsigned char const k2[16] = { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 };
|
||||
static unsigned char const k1[16] = { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 };
|
||||
|
||||
/* Byte-at-a-time substitution boxes */
|
||||
static unsigned char k87[256];
|
||||
static unsigned char k65[256];
|
||||
static unsigned char k43[256];
|
||||
static unsigned char k21[256];
|
||||
|
||||
/*
|
||||
* Build byte-at-a-time subtitution tables.
|
||||
* This must be called once for global setup.
|
||||
*/
|
||||
#include <stdio.h>
|
||||
|
||||
void kboxinit(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
k87[i] = k8[i >> 4] << 4 | k7[i & 15];
|
||||
k65[i] = k6[i >> 4] << 4 | k5[i & 15];
|
||||
k43[i] = k4[i >> 4] << 4 | k3[i & 15];
|
||||
k21[i] = k2[i >> 4] << 4 | k1[i & 15];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Do the substitution and rotation that are the core of the operation,
|
||||
* like the expansion, substitution and permutation of the DES.
|
||||
* It would be possible to perform DES-like optimisations and store
|
||||
* the table entries as 32-bit words, already rotated, but the
|
||||
* efficiency gain is questionable.
|
||||
*
|
||||
* This should be inlined for maximum speed
|
||||
*/
|
||||
#if __GNUC__
|
||||
__inline__
|
||||
#endif
|
||||
static word32 f(word32 x)
|
||||
{
|
||||
/* Do substitutions */
|
||||
#if 0
|
||||
/* This is annoyingly slow */
|
||||
x = k8[x>>28 & 15] << 28 | k7[x>>24 & 15] << 24 |
|
||||
k6[x>>20 & 15] << 20 | k5[x>>16 & 15] << 16 |
|
||||
k4[x>>12 & 15] << 12 | k3[x>> 8 & 15] << 8 |
|
||||
k2[x>> 4 & 15] << 4 | k1[x & 15];
|
||||
#else
|
||||
/* This is faster */
|
||||
x = k87[x>>24 & 255] << 24 | k65[x>>16 & 255] << 16 | k43[x>> 8 & 255] << 8 | k21[x & 255];
|
||||
#endif
|
||||
|
||||
/* Rotate left 11 bits */
|
||||
return x << 11 | x >> (32 - 11);
|
||||
}
|
||||
|
||||
/*
|
||||
* The GOST standard defines the input in terms of bits 1..64, with
|
||||
* bit 1 being the lsb of in[0] and bit 64 being the msb of in[1].
|
||||
*
|
||||
* The keys are defined similarly, with bit 256 being the msb of key[7].
|
||||
*/
|
||||
void gostcrypt(word32 const in[2], word32 out[2], word32 const key[8])
|
||||
{
|
||||
register word32 n1, n2; /* As named in the GOST */
|
||||
|
||||
n1 = in[0];
|
||||
n2 = in[1];
|
||||
|
||||
/* Instead of swapping halves, swap names each round */
|
||||
n2 ^= f(n1+key[0]);
|
||||
n1 ^= f(n2+key[1]);
|
||||
n2 ^= f(n1+key[2]);
|
||||
n1 ^= f(n2+key[3]);
|
||||
n2 ^= f(n1+key[4]);
|
||||
n1 ^= f(n2+key[5]);
|
||||
n2 ^= f(n1+key[6]);
|
||||
n1 ^= f(n2+key[7]);
|
||||
|
||||
n2 ^= f(n1+key[0]);
|
||||
n1 ^= f(n2+key[1]);
|
||||
n2 ^= f(n1+key[2]);
|
||||
n1 ^= f(n2+key[3]);
|
||||
n2 ^= f(n1+key[4]);
|
||||
n1 ^= f(n2+key[5]);
|
||||
n2 ^= f(n1+key[6]);
|
||||
n1 ^= f(n2+key[7]);
|
||||
|
||||
n2 ^= f(n1+key[0]);
|
||||
n1 ^= f(n2+key[1]);
|
||||
n2 ^= f(n1+key[2]);
|
||||
n1 ^= f(n2+key[3]);
|
||||
n2 ^= f(n1+key[4]);
|
||||
n1 ^= f(n2+key[5]);
|
||||
n2 ^= f(n1+key[6]);
|
||||
n1 ^= f(n2+key[7]);
|
||||
|
||||
n2 ^= f(n1+key[7]);
|
||||
n1 ^= f(n2+key[6]);
|
||||
n2 ^= f(n1+key[5]);
|
||||
n1 ^= f(n2+key[4]);
|
||||
n2 ^= f(n1+key[3]);
|
||||
n1 ^= f(n2+key[2]);
|
||||
n2 ^= f(n1+key[1]);
|
||||
n1 ^= f(n2+key[0]);
|
||||
|
||||
/* There is no swap after the last round */
|
||||
out[0] = n2;
|
||||
out[1] = n1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The key schedule is somewhat different for decryption.
|
||||
* (The key table is used once forward and three times backward.)
|
||||
* You could define an expanded key, or just write the code twice,
|
||||
* as done here.
|
||||
*/
|
||||
void gostdecrypt(word32 const in[2], word32 out[2], word32 const key[8])
|
||||
{
|
||||
register word32 n1, n2; /* As named in the GOST */
|
||||
|
||||
n1 = in[0];
|
||||
n2 = in[1];
|
||||
|
||||
n2 ^= f(n1+key[0]);
|
||||
n1 ^= f(n2+key[1]);
|
||||
n2 ^= f(n1+key[2]);
|
||||
n1 ^= f(n2+key[3]);
|
||||
n2 ^= f(n1+key[4]);
|
||||
n1 ^= f(n2+key[5]);
|
||||
n2 ^= f(n1+key[6]);
|
||||
n1 ^= f(n2+key[7]);
|
||||
|
||||
n2 ^= f(n1+key[7]);
|
||||
n1 ^= f(n2+key[6]);
|
||||
n2 ^= f(n1+key[5]);
|
||||
n1 ^= f(n2+key[4]);
|
||||
n2 ^= f(n1+key[3]);
|
||||
n1 ^= f(n2+key[2]);
|
||||
n2 ^= f(n1+key[1]);
|
||||
n1 ^= f(n2+key[0]);
|
||||
|
||||
n2 ^= f(n1+key[7]);
|
||||
n1 ^= f(n2+key[6]);
|
||||
n2 ^= f(n1+key[5]);
|
||||
n1 ^= f(n2+key[4]);
|
||||
n2 ^= f(n1+key[3]);
|
||||
n1 ^= f(n2+key[2]);
|
||||
n2 ^= f(n1+key[1]);
|
||||
n1 ^= f(n2+key[0]);
|
||||
|
||||
n2 ^= f(n1+key[7]);
|
||||
n1 ^= f(n2+key[6]);
|
||||
n2 ^= f(n1+key[5]);
|
||||
n1 ^= f(n2+key[4]);
|
||||
n2 ^= f(n1+key[3]);
|
||||
n1 ^= f(n2+key[2]);
|
||||
n2 ^= f(n1+key[1]);
|
||||
n1 ^= f(n2+key[0]);
|
||||
|
||||
out[0] = n2;
|
||||
out[1] = n1;
|
||||
}
|
||||
|
||||
/*
|
||||
* The GOST "Output feedback" standard. It seems closer morally
|
||||
* to the counter feedback mode some people have proposed for DES.
|
||||
* The avoidance of the short cycles that are possible in OFB seems
|
||||
* like a Good Thing.
|
||||
*
|
||||
* Calling it the stream mode makes more sense.
|
||||
*
|
||||
* The IV is encrypted with the key to produce the initial counter value.
|
||||
* Then, for each output block, a constant is added, modulo 2^32-1
|
||||
* (0 is represented as all-ones, not all-zeros), to each half of
|
||||
* the counter, and the counter is encrypted to produce the value
|
||||
* to XOR with the output.
|
||||
*
|
||||
* Len is the number of blocks. Sub-block encryption is
|
||||
* left as an exercise for the user. Remember that the
|
||||
* standard defines everything in a little-endian manner,
|
||||
* so you want to use the low bit of gamma[0] first.
|
||||
*
|
||||
* OFB is, of course, self-inverse, so there is only one function.
|
||||
*/
|
||||
|
||||
/* The constants for addition */
|
||||
#define C1 0x01010104
|
||||
#define C2 0x01010101
|
||||
|
||||
void gostofb(word32 const *in, word32 *out, int len, word32 const iv[2], word32 const key[8])
|
||||
{
|
||||
word32 temp[2]; /* Counter */
|
||||
word32 gamma[2]; /* Output XOR value */
|
||||
|
||||
/* Compute starting value for counter */
|
||||
gostcrypt(iv, temp, key);
|
||||
|
||||
while (len--)
|
||||
{
|
||||
temp[0] += C2;
|
||||
|
||||
if (temp[0] < C2) /* Wrap modulo 2^32? */
|
||||
temp[0]++; /* Make it modulo 2^32-1 */
|
||||
|
||||
temp[1] += C1;
|
||||
|
||||
if (temp[1] < C1) /* Wrap modulo 2^32? */
|
||||
temp[1]++; /* Make it modulo 2^32-1 */
|
||||
|
||||
gostcrypt(temp, gamma, key);
|
||||
|
||||
*out++ = *in++ ^ gamma[0];
|
||||
*out++ = *in++ ^ gamma[1];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* The CFB mode is just what you'd expect. Each block of ciphertext y[] is
|
||||
* derived from the input x[] by the following pseudocode:
|
||||
* y[i] = x[i] ^ gostcrypt(y[i-1])
|
||||
* x[i] = y[i] ^ gostcrypt(y[i-1])
|
||||
* Where y[-1] is the IV.
|
||||
*
|
||||
* The IV is modified in place. Again, len is in *blocks*.
|
||||
*/
|
||||
|
||||
void gostcfbencrypt(word32 const *in, word32 *out, int len, word32 iv[2], word32 const key[8])
|
||||
{
|
||||
while (len--)
|
||||
{
|
||||
gostcrypt(iv, iv, key);
|
||||
iv[0] = *out++ ^= iv[0];
|
||||
iv[1] = *out++ ^= iv[1];
|
||||
}
|
||||
}
|
||||
|
||||
void gostcfbdecrypt(word32 const *in, word32 *out, int len, word32 iv[2], word32 const key[8])
|
||||
{
|
||||
word32 t;
|
||||
|
||||
while (len--)
|
||||
{
|
||||
gostcrypt(iv, iv, key);
|
||||
t = *out;
|
||||
*out++ ^= iv[0];
|
||||
iv[0] = t;
|
||||
t = *out;
|
||||
*out++ ^= iv[1];
|
||||
iv[1] = t;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The message suthetication code uses only 16 of the 32 rounds.
|
||||
* There *is* a swap after the 16th round.
|
||||
* The last block should be padded to 64 bits with zeros.
|
||||
* len is the number of *blocks* in the input.
|
||||
*/
|
||||
void gostmac(word32 const *in, int len, word32 out[2], word32 const key[8])
|
||||
{
|
||||
register word32 n1, n2; /* As named in the GOST */
|
||||
|
||||
n1 = 0;
|
||||
n2 = 0;
|
||||
|
||||
while (len--)
|
||||
{
|
||||
n1 ^= *in++;
|
||||
n2 = *in++;
|
||||
|
||||
/* Instead of swapping halves, swap names each round */
|
||||
n2 ^= f(n1+key[0]);
|
||||
n1 ^= f(n2+key[1]);
|
||||
n2 ^= f(n1+key[2]);
|
||||
n1 ^= f(n2+key[3]);
|
||||
n2 ^= f(n1+key[4]);
|
||||
n1 ^= f(n2+key[5]);
|
||||
n2 ^= f(n1+key[6]);
|
||||
n1 ^= f(n2+key[7]);
|
||||
|
||||
n2 ^= f(n1+key[0]);
|
||||
n1 ^= f(n2+key[1]);
|
||||
n2 ^= f(n1+key[2]);
|
||||
n1 ^= f(n2+key[3]);
|
||||
n2 ^= f(n1+key[4]);
|
||||
n1 ^= f(n2+key[5]);
|
||||
n2 ^= f(n1+key[6]);
|
||||
n1 ^= f(n2+key[7]);
|
||||
}
|
||||
|
||||
out[0] = n1;
|
||||
out[1] = n2;
|
||||
}
|
||||
|
||||
#ifdef TEST
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/* Designed to cope with 15-bit rand() implementations */
|
||||
#define RAND32 ((word32)rand() << 17 ^ (word32)rand() << 9 ^ rand())
|
||||
|
||||
int main(void)
|
||||
{
|
||||
word32 key[8];
|
||||
word32 plain[2];
|
||||
word32 cipher[2];
|
||||
int i, j;
|
||||
|
||||
kboxinit();
|
||||
|
||||
printf("GOST 21847-89 test driver.\n");
|
||||
|
||||
for (i = 0; i < 1000; i++)
|
||||
{
|
||||
for (j = 0; j < 8; j++)
|
||||
key[j] = RAND32;
|
||||
|
||||
plain[0] = RAND32;
|
||||
plain[1] = RAND32;
|
||||
|
||||
printf("%3d\r", i);
|
||||
fflush(stdout);
|
||||
|
||||
gostcrypt(plain, cipher, key);
|
||||
|
||||
for (j = 0; j < 99; j++)
|
||||
gostcrypt(cipher, cipher, key);
|
||||
|
||||
for (j = 0; j < 100; j++)
|
||||
gostdecrypt(cipher, cipher, key);
|
||||
|
||||
if (plain[0] != cipher[0] || plain[1] != cipher[1])
|
||||
{
|
||||
fprintf(stderr, "\nError! i = %d\n", i);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
printf("All tests passed.\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* TEST */
|
||||
@ -1,123 +0,0 @@
|
||||
/*
|
||||
* Filename: hangul.c
|
||||
* Description: <20>ѱ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ҽ<EFBFBD>
|
||||
*
|
||||
* Author: <20><><EFBFBD><EFBFBD> aka. Cronan
|
||||
*/
|
||||
#define __LIBTHECORE__
|
||||
#include "stdafx.h"
|
||||
|
||||
int is_hangul(const BYTE * str)
|
||||
{
|
||||
if (str[0] >= 0xb0 && str[0] <= 0xc8 && str[1] >= 0xa1 && str[1] <= 0xfe)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int check_han(const char *str)
|
||||
{
|
||||
int i, code;
|
||||
|
||||
if (!str || !*str)
|
||||
return 0;
|
||||
|
||||
for (i = 0; str[i]; i += 2)
|
||||
{
|
||||
if (isnhspace(str[i]))
|
||||
return 0;
|
||||
|
||||
if (isalpha(str[i]) || isdigit(str[i]))
|
||||
continue;
|
||||
|
||||
code = str[i];
|
||||
code += 256;
|
||||
|
||||
if (code < 176 || code > 200)
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
const char *first_han(const BYTE *str)
|
||||
{
|
||||
unsigned char high, low;
|
||||
int len, i;
|
||||
char *p = "<EFBFBD><EFBFBD>";
|
||||
|
||||
static const char* wansung[] =
|
||||
{
|
||||
"<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>",
|
||||
"<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>",
|
||||
"<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>",
|
||||
"ī", "Ÿ", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", ""
|
||||
};
|
||||
|
||||
static const char* johab[] =
|
||||
{
|
||||
"<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a",
|
||||
"<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a",
|
||||
"<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a",
|
||||
"<EFBFBD>a", "?", "?", "?", ""
|
||||
};
|
||||
|
||||
len = strlen((const char*) str);
|
||||
|
||||
if (len < 2)
|
||||
return p;
|
||||
|
||||
high = str[0];
|
||||
low = str[1];
|
||||
|
||||
if (!is_hangul(str))
|
||||
{
|
||||
return p;
|
||||
}
|
||||
|
||||
high = (KStbl[(high - 0xb0) * 94 + low - 0xa1] >> 8) & 0x7c;
|
||||
|
||||
for (i = 0; johab[i][0]; i++)
|
||||
{
|
||||
low = (johab[i][0] & 0x7f);
|
||||
|
||||
if (low == high)
|
||||
return (wansung[i]);
|
||||
}
|
||||
|
||||
return (p);
|
||||
}
|
||||
|
||||
int under_han(const void * orig)
|
||||
{
|
||||
const BYTE * str = (const BYTE *) orig;
|
||||
BYTE high, low;
|
||||
int len;
|
||||
|
||||
len = strlen((const char*) str);
|
||||
|
||||
if (len < 2)
|
||||
return 0;
|
||||
|
||||
if (str[len - 1] == ')')
|
||||
{
|
||||
while (str[len] != '(')
|
||||
len--;
|
||||
}
|
||||
|
||||
high = str[len - 2];
|
||||
low = str[len - 1];
|
||||
|
||||
if (!is_hangul(&str[len - 2]))
|
||||
return 0;
|
||||
|
||||
high = KStbl[(high - 0xb0) * 94 + low - 0xa1] & 0x1f;
|
||||
|
||||
if (high < 2)
|
||||
return 0;
|
||||
|
||||
if (high > 28)
|
||||
return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
@ -1,335 +0,0 @@
|
||||
/*
|
||||
* Filename: kstbl.c
|
||||
* Description: <20>Ʒ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>δ<EFBFBD>.
|
||||
*
|
||||
* Author: <20><><EFBFBD><EFBFBD> aka. Cronan
|
||||
*/
|
||||
#define __LIBTHECORE__
|
||||
unsigned KStbl[2350] =
|
||||
{
|
||||
/* KS <20>ϼ<EFBFBD><CFBC><EFBFBD> 2350<35><30><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ<EFBFBD> */
|
||||
0x8861,0x8862,0x8865,0x8868,0x8869,0x886a,0x886b,0x8871,
|
||||
0x8873,0x8874,0x8875,0x8876,0x8877,0x8878,0x8879,0x887b,
|
||||
0x887c,0x887d,0x8881,0x8882,0x8885,0x8889,0x8891,0x8893,
|
||||
0x8895,0x8896,0x8897,0x88a1,0x88a2,0x88a5,0x88a9,0x88b5,
|
||||
0x88b7,0x88c1,0x88c5,0x88c9,0x88e1,0x88e2,0x88e5,0x88e8,
|
||||
0x88e9,0x88eb,0x88f1,0x88f3,0x88f5,0x88f6,0x88f7,0x88f8,
|
||||
0x88fb,0x88fc,0x88fd,0x8941,0x8945,0x8949,0x8951,0x8953,
|
||||
0x8955,0x8956,0x8957,0x8961,0x8962,0x8963,0x8965,0x8968,
|
||||
0x8969,0x8971,0x8973,0x8975,0x8976,0x8977,0x897b,0x8981,
|
||||
0x8985,0x8989,0x8993,0x8995,0x89a1,0x89a2,0x89a5,0x89a8,
|
||||
0x89a9,0x89ab,0x89ad,0x89b0,0x89b1,0x89b3,0x89b5,0x89b7,
|
||||
0x89b8,0x89c1,0x89c2,0x89c5,0x89c9,0x89cb,
|
||||
|
||||
0x89d1,0x89d3,0x89d5,0x89d7,0x89e1,0x89e5,0x89e9,0x89f1,
|
||||
0x89f6,0x89f7,0x8a41,0x8a42,0x8a45,0x8a49,0x8a51,0x8a53,
|
||||
0x8a55,0x8a57,0x8a61,0x8a65,0x8a69,0x8a73,0x8a75,0x8a81,
|
||||
0x8a82,0x8a85,0x8a88,0x8a89,0x8a8a,0x8a8b,0x8a90,0x8a91,
|
||||
0x8a93,0x8a95,0x8a97,0x8a98,0x8aa1,0x8aa2,0x8aa5,0x8aa9,
|
||||
0x8ab6,0x8ab7,0x8ac1,0x8ad5,0x8ae1,0x8ae2,0x8ae5,0x8ae9,
|
||||
0x8af1,0x8af3,0x8af5,0x8b41,0x8b45,0x8b49,0x8b61,0x8b62,
|
||||
0x8b65,0x8b68,0x8b69,0x8b6a,0x8b71,0x8b73,0x8b75,0x8b77,
|
||||
0x8b81,0x8ba1,0x8ba2,0x8ba5,0x8ba8,0x8ba9,0x8bab,0x8bb1,
|
||||
0x8bb3,0x8bb5,0x8bb7,0x8bb8,0x8bbc,0x8c61,0x8c62,0x8c63,
|
||||
0x8c65,0x8c69,0x8c6b,0x8c71,0x8c73,0x8c75,0x8c76,0x8c77,
|
||||
0x8c7b,0x8c81,0x8c82,0x8c85,0x8c89,0x8c91,
|
||||
|
||||
0x8c93,0x8c95,0x8c96,0x8c97,0x8ca1,0x8ca2,0x8ca9,0x8ce1,
|
||||
0x8ce2,0x8ce3,0x8ce5,0x8ce9,0x8cf1,0x8cf3,0x8cf5,0x8cf6,
|
||||
0x8cf7,0x8d41,0x8d42,0x8d45,0x8d51,0x8d55,0x8d57,0x8d61,
|
||||
0x8d65,0x8d69,0x8d75,0x8d76,0x8d7b,0x8d81,0x8da1,0x8da2,
|
||||
0x8da5,0x8da7,0x8da9,0x8db1,0x8db3,0x8db5,0x8db7,0x8db8,
|
||||
0x8db9,0x8dc1,0x8dc2,0x8dc9,0x8dd6,0x8dd7,0x8de1,0x8de2,
|
||||
0x8df7,0x8e41,0x8e45,0x8e49,0x8e51,0x8e53,0x8e57,0x8e61,
|
||||
0x8e81,0x8e82,0x8e85,0x8e89,0x8e90,0x8e91,0x8e93,0x8e95,
|
||||
0x8e97,0x8e98,0x8ea1,0x8ea9,0x8eb6,0x8eb7,0x8ec1,0x8ec2,
|
||||
0x8ec5,0x8ec9,0x8ed1,0x8ed3,0x8ed6,0x8ee1,0x8ee5,0x8ee9,
|
||||
0x8ef1,0x8ef3,0x8f41,0x8f61,0x8f62,0x8f65,0x8f67,0x8f69,
|
||||
0x8f6b,0x8f70,0x8f71,0x8f73,0x8f75,0x8f77,
|
||||
|
||||
0x8f7b,0x8fa1,0x8fa2,0x8fa5,0x8fa9,0x8fb1,0x8fb3,0x8fb5,
|
||||
0x8fb7,0x9061,0x9062,0x9063,0x9065,0x9068,0x9069,0x906a,
|
||||
0x906b,0x9071,0x9073,0x9075,0x9076,0x9077,0x9078,0x9079,
|
||||
0x907b,0x907d,0x9081,0x9082,0x9085,0x9089,0x9091,0x9093,
|
||||
0x9095,0x9096,0x9097,0x90a1,0x90a2,0x90a5,0x90a9,0x90b1,
|
||||
0x90b7,0x90e1,0x90e2,0x90e4,0x90e5,0x90e9,0x90eb,0x90ec,
|
||||
0x90f1,0x90f3,0x90f5,0x90f6,0x90f7,0x90fd,0x9141,0x9142,
|
||||
0x9145,0x9149,0x9151,0x9153,0x9155,0x9156,0x9157,0x9161,
|
||||
0x9162,0x9165,0x9169,0x9171,0x9173,0x9176,0x9177,0x917a,
|
||||
0x9181,0x9185,0x91a1,0x91a2,0x91a5,0x91a9,0x91ab,0x91b1,
|
||||
0x91b3,0x91b5,0x91b7,0x91bc,0x91bd,0x91c1,0x91c5,0x91c9,
|
||||
0x91d6,0x9241,0x9245,0x9249,0x9251,0x9253,
|
||||
|
||||
0x9255,0x9261,0x9262,0x9265,0x9269,0x9273,0x9275,0x9277,
|
||||
0x9281,0x9282,0x9285,0x9288,0x9289,0x9291,0x9293,0x9295,
|
||||
0x9297,0x92a1,0x92b6,0x92c1,0x92e1,0x92e5,0x92e9,0x92f1,
|
||||
0x92f3,0x9341,0x9342,0x9349,0x9351,0x9353,0x9357,0x9361,
|
||||
0x9362,0x9365,0x9369,0x936a,0x936b,0x9371,0x9373,0x9375,
|
||||
0x9377,0x9378,0x937c,0x9381,0x9385,0x9389,0x93a1,0x93a2,
|
||||
0x93a5,0x93a9,0x93af,0x93b1,0x93b3,0x93b5,0x93b7,0x93bc,
|
||||
0x9461,0x9462,0x9463,0x9465,0x9468,0x9469,0x946a,0x946b,
|
||||
0x946c,0x9470,0x9471,0x9473,0x9475,0x9476,0x9477,0x9478,
|
||||
0x9479,0x947d,0x9481,0x9482,0x9485,0x9489,0x9491,0x9493,
|
||||
0x9495,0x9496,0x9497,0x94a1,0x94e1,0x94e2,0x94e3,0x94e5,
|
||||
0x94e8,0x94e9,0x94eb,0x94ec,0x94f1,0x94f3,
|
||||
|
||||
0x94f5,0x94f7,0x94f9,0x94fc,0x9541,0x9542,0x9545,0x9549,
|
||||
0x9551,0x9553,0x9555,0x9556,0x9557,0x9561,0x9565,0x9569,
|
||||
0x9576,0x9577,0x9581,0x9585,0x95a1,0x95a2,0x95a5,0x95a8,
|
||||
0x95a9,0x95ab,0x95ad,0x95b1,0x95b3,0x95b5,0x95b7,0x95b9,
|
||||
0x95bb,0x95c1,0x95c5,0x95c9,0x95e1,0x95f6,0x9641,0x9645,
|
||||
0x9649,0x9651,0x9653,0x9655,0x9661,0x9681,0x9682,0x9685,
|
||||
0x9689,0x9691,0x9693,0x9695,0x9697,0x96a1,0x96b6,0x96c1,
|
||||
0x96d7,0x96e1,0x96e5,0x96e9,0x96f3,0x96f5,0x96f7,0x9741,
|
||||
0x9745,0x9749,0x9751,0x9757,0x9761,0x9762,0x9765,0x9768,
|
||||
0x9769,0x976b,0x9771,0x9773,0x9775,0x9777,0x9781,0x97a1,
|
||||
0x97a2,0x97a5,0x97a8,0x97a9,0x97b1,0x97b3,0x97b5,0x97b6,
|
||||
0x97b7,0x97b8,0x9861,0x9862,0x9865,0x9869,
|
||||
|
||||
0x9871,0x9873,0x9875,0x9876,0x9877,0x987d,0x9881,0x9882,
|
||||
0x9885,0x9889,0x9891,0x9893,0x9895,0x9896,0x9897,0x98e1,
|
||||
0x98e2,0x98e5,0x98e9,0x98eb,0x98ec,0x98f1,0x98f3,0x98f5,
|
||||
0x98f6,0x98f7,0x98fd,0x9941,0x9942,0x9945,0x9949,0x9951,
|
||||
0x9953,0x9955,0x9956,0x9957,0x9961,0x9976,0x99a1,0x99a2,
|
||||
0x99a5,0x99a9,0x99b7,0x99c1,0x99c9,0x99e1,0x9a41,0x9a45,
|
||||
0x9a81,0x9a82,0x9a85,0x9a89,0x9a90,0x9a91,0x9a97,0x9ac1,
|
||||
0x9ae1,0x9ae5,0x9ae9,0x9af1,0x9af3,0x9af7,0x9b61,0x9b62,
|
||||
0x9b65,0x9b68,0x9b69,0x9b71,0x9b73,0x9b75,0x9b81,0x9b85,
|
||||
0x9b89,0x9b91,0x9b93,0x9ba1,0x9ba5,0x9ba9,0x9bb1,0x9bb3,
|
||||
0x9bb5,0x9bb7,0x9c61,0x9c62,0x9c65,0x9c69,0x9c71,0x9c73,
|
||||
0x9c75,0x9c76,0x9c77,0x9c78,0x9c7c,0x9c7d,
|
||||
|
||||
0x9c81,0x9c82,0x9c85,0x9c89,0x9c91,0x9c93,0x9c95,0x9c96,
|
||||
0x9c97,0x9ca1,0x9ca2,0x9ca5,0x9cb5,0x9cb7,0x9ce1,0x9ce2,
|
||||
0x9ce5,0x9ce9,0x9cf1,0x9cf3,0x9cf5,0x9cf6,0x9cf7,0x9cfd,
|
||||
0x9d41,0x9d42,0x9d45,0x9d49,0x9d51,0x9d53,0x9d55,0x9d57,
|
||||
0x9d61,0x9d62,0x9d65,0x9d69,0x9d71,0x9d73,0x9d75,0x9d76,
|
||||
0x9d77,0x9d81,0x9d85,0x9d93,0x9d95,0x9da1,0x9da2,0x9da5,
|
||||
0x9da9,0x9db1,0x9db3,0x9db5,0x9db7,0x9dc1,0x9dc5,0x9dd7,
|
||||
0x9df6,0x9e41,0x9e45,0x9e49,0x9e51,0x9e53,0x9e55,0x9e57,
|
||||
0x9e61,0x9e65,0x9e69,0x9e73,0x9e75,0x9e77,0x9e81,0x9e82,
|
||||
0x9e85,0x9e89,0x9e91,0x9e93,0x9e95,0x9e97,0x9ea1,0x9eb6,
|
||||
0x9ec1,0x9ee1,0x9ee2,0x9ee5,0x9ee9,0x9ef1,0x9ef5,0x9ef7,
|
||||
0x9f41,0x9f42,0x9f45,0x9f49,0x9f51,0x9f53,
|
||||
|
||||
0x9f55,0x9f57,0x9f61,0x9f62,0x9f65,0x9f69,0x9f71,0x9f73,
|
||||
0x9f75,0x9f77,0x9f78,0x9f7b,0x9f7c,0x9fa1,0x9fa2,0x9fa5,
|
||||
0x9fa9,0x9fb1,0x9fb3,0x9fb5,0x9fb7,0xa061,0xa062,0xa065,
|
||||
0xa067,0xa068,0xa069,0xa06a,0xa06b,0xa071,0xa073,0xa075,
|
||||
0xa077,0xa078,0xa07b,0xa07d,0xa081,0xa082,0xa085,0xa089,
|
||||
0xa091,0xa093,0xa095,0xa096,0xa097,0xa098,0xa0a1,0xa0a2,
|
||||
0xa0a9,0xa0b7,0xa0e1,0xa0e2,0xa0e5,0xa0e9,0xa0eb,0xa0f1,
|
||||
0xa0f3,0xa0f5,0xa0f7,0xa0f8,0xa0fd,0xa141,0xa142,0xa145,
|
||||
0xa149,0xa151,0xa153,0xa155,0xa156,0xa157,0xa161,0xa162,
|
||||
0xa165,0xa169,0xa175,0xa176,0xa177,0xa179,0xa181,0xa1a1,
|
||||
0xa1a2,0xa1a4,0xa1a5,0xa1a9,0xa1ab,0xa1b1,0xa1b3,0xa1b5,
|
||||
0xa1b7,0xa1c1,0xa1c5,0xa1d6,0xa1d7,0xa241,
|
||||
|
||||
0xa245,0xa249,0xa253,0xa255,0xa257,0xa261,0xa265,0xa269,
|
||||
0xa273,0xa275,0xa281,0xa282,0xa283,0xa285,0xa288,0xa289,
|
||||
0xa28a,0xa28b,0xa291,0xa293,0xa295,0xa297,0xa29b,0xa29d,
|
||||
0xa2a1,0xa2a5,0xa2a9,0xa2b3,0xa2b5,0xa2c1,0xa2e1,0xa2e5,
|
||||
0xa2e9,0xa341,0xa345,0xa349,0xa351,0xa355,0xa361,0xa365,
|
||||
0xa369,0xa371,0xa375,0xa3a1,0xa3a2,0xa3a5,0xa3a8,0xa3a9,
|
||||
0xa3ab,0xa3b1,0xa3b3,0xa3b5,0xa3b6,0xa3b7,0xa3b9,0xa3bb,
|
||||
0xa461,0xa462,0xa463,0xa464,0xa465,0xa468,0xa469,0xa46a,
|
||||
0xa46b,0xa46c,0xa471,0xa473,0xa475,0xa477,0xa47b,0xa481,
|
||||
0xa482,0xa485,0xa489,0xa491,0xa493,0xa495,0xa496,0xa497,
|
||||
0xa49b,0xa4a1,0xa4a2,0xa4a5,0xa4b3,0xa4e1,0xa4e2,0xa4e5,
|
||||
0xa4e8,0xa4e9,0xa4eb,0xa4f1,0xa4f3,0xa4f5,
|
||||
|
||||
0xa4f7,0xa4f8,0xa541,0xa542,0xa545,0xa548,0xa549,0xa551,
|
||||
0xa553,0xa555,0xa556,0xa557,0xa561,0xa562,0xa565,0xa569,
|
||||
0xa573,0xa575,0xa576,0xa577,0xa57b,0xa581,0xa585,0xa5a1,
|
||||
0xa5a2,0xa5a3,0xa5a5,0xa5a9,0xa5b1,0xa5b3,0xa5b5,0xa5b7,
|
||||
0xa5c1,0xa5c5,0xa5d6,0xa5e1,0xa5f6,0xa641,0xa642,0xa645,
|
||||
0xa649,0xa651,0xa653,0xa661,0xa665,0xa681,0xa682,0xa685,
|
||||
0xa688,0xa689,0xa68a,0xa68b,0xa691,0xa693,0xa695,0xa697,
|
||||
0xa69b,0xa69c,0xa6a1,0xa6a9,0xa6b6,0xa6c1,0xa6e1,0xa6e2,
|
||||
0xa6e5,0xa6e9,0xa6f7,0xa741,0xa745,0xa749,0xa751,0xa755,
|
||||
0xa757,0xa761,0xa762,0xa765,0xa769,0xa771,0xa773,0xa775,
|
||||
0xa7a1,0xa7a2,0xa7a5,0xa7a9,0xa7ab,0xa7b1,0xa7b3,0xa7b5,
|
||||
0xa7b7,0xa7b8,0xa7b9,0xa861,0xa862,0xa865,
|
||||
|
||||
0xa869,0xa86b,0xa871,0xa873,0xa875,0xa876,0xa877,0xa87d,
|
||||
0xa881,0xa882,0xa885,0xa889,0xa891,0xa893,0xa895,0xa896,
|
||||
0xa897,0xa8a1,0xa8a2,0xa8b1,0xa8e1,0xa8e2,0xa8e5,0xa8e8,
|
||||
0xa8e9,0xa8f1,0xa8f5,0xa8f6,0xa8f7,0xa941,0xa957,0xa961,
|
||||
0xa962,0xa971,0xa973,0xa975,0xa976,0xa977,0xa9a1,0xa9a2,
|
||||
0xa9a5,0xa9a9,0xa9b1,0xa9b3,0xa9b7,0xaa41,0xaa61,0xaa77,
|
||||
0xaa81,0xaa82,0xaa85,0xaa89,0xaa91,0xaa95,0xaa97,0xab41,
|
||||
0xab57,0xab61,0xab65,0xab69,0xab71,0xab73,0xaba1,0xaba2,
|
||||
0xaba5,0xaba9,0xabb1,0xabb3,0xabb5,0xabb7,0xac61,0xac62,
|
||||
0xac64,0xac65,0xac68,0xac69,0xac6a,0xac6b,0xac71,0xac73,
|
||||
0xac75,0xac76,0xac77,0xac7b,0xac81,0xac82,0xac85,0xac89,
|
||||
0xac91,0xac93,0xac95,0xac96,0xac97,0xaca1,
|
||||
|
||||
0xaca2,0xaca5,0xaca9,0xacb1,0xacb3,0xacb5,0xacb7,0xacc1,
|
||||
0xacc5,0xacc9,0xacd1,0xacd7,0xace1,0xace2,0xace3,0xace4,
|
||||
0xace5,0xace8,0xace9,0xaceb,0xacec,0xacf1,0xacf3,0xacf5,
|
||||
0xacf6,0xacf7,0xacfc,0xad41,0xad42,0xad45,0xad49,0xad51,
|
||||
0xad53,0xad55,0xad56,0xad57,0xad61,0xad62,0xad65,0xad69,
|
||||
0xad71,0xad73,0xad75,0xad76,0xad77,0xad81,0xad85,0xad89,
|
||||
0xad97,0xada1,0xada2,0xada3,0xada5,0xada9,0xadab,0xadb1,
|
||||
0xadb3,0xadb5,0xadb7,0xadbb,0xadc1,0xadc2,0xadc5,0xadc9,
|
||||
0xadd7,0xade1,0xade5,0xade9,0xadf1,0xadf5,0xadf6,0xae41,
|
||||
0xae45,0xae49,0xae51,0xae53,0xae55,0xae61,0xae62,0xae65,
|
||||
0xae69,0xae71,0xae73,0xae75,0xae77,0xae81,0xae82,0xae85,
|
||||
0xae88,0xae89,0xae91,0xae93,0xae95,0xae97,
|
||||
|
||||
0xae99,0xae9b,0xae9c,0xaea1,0xaeb6,0xaec1,0xaec2,0xaec5,
|
||||
0xaec9,0xaed1,0xaed7,0xaee1,0xaee2,0xaee5,0xaee9,0xaef1,
|
||||
0xaef3,0xaef5,0xaef7,0xaf41,0xaf42,0xaf49,0xaf51,0xaf55,
|
||||
0xaf57,0xaf61,0xaf62,0xaf65,0xaf69,0xaf6a,0xaf71,0xaf73,
|
||||
0xaf75,0xaf77,0xafa1,0xafa2,0xafa5,0xafa8,0xafa9,0xafb0,
|
||||
0xafb1,0xafb3,0xafb5,0xafb7,0xafbc,0xb061,0xb062,0xb064,
|
||||
0xb065,0xb069,0xb071,0xb073,0xb076,0xb077,0xb07d,0xb081,
|
||||
0xb082,0xb085,0xb089,0xb091,0xb093,0xb096,0xb097,0xb0b7,
|
||||
0xb0e1,0xb0e2,0xb0e5,0xb0e9,0xb0eb,0xb0f1,0xb0f3,0xb0f6,
|
||||
0xb0f7,0xb141,0xb145,0xb149,0xb157,0xb1a1,0xb1a2,0xb1a5,
|
||||
0xb1a8,0xb1a9,0xb1ab,0xb1b1,0xb1b3,0xb1b7,0xb1c1,0xb1c2,
|
||||
0xb1c5,0xb1d6,0xb1e1,0xb1f6,0xb241,0xb245,
|
||||
|
||||
0xb249,0xb251,0xb253,0xb261,0xb281,0xb282,0xb285,0xb289,
|
||||
0xb291,0xb293,0xb297,0xb2a1,0xb2b6,0xb2c1,0xb2e1,0xb2e5,
|
||||
0xb357,0xb361,0xb362,0xb365,0xb369,0xb36b,0xb370,0xb371,
|
||||
0xb373,0xb381,0xb385,0xb389,0xb391,0xb3a1,0xb3a2,0xb3a5,
|
||||
0xb3a9,0xb3b1,0xb3b3,0xb3b5,0xb3b7,0xb461,0xb462,0xb465,
|
||||
0xb466,0xb467,0xb469,0xb46a,0xb46b,0xb470,0xb471,0xb473,
|
||||
0xb475,0xb476,0xb477,0xb47b,0xb47c,0xb481,0xb482,0xb485,
|
||||
0xb489,0xb491,0xb493,0xb495,0xb496,0xb497,0xb4a1,0xb4a2,
|
||||
0xb4a5,0xb4a9,0xb4ac,0xb4b1,0xb4b3,0xb4b5,0xb4b7,0xb4bb,
|
||||
0xb4bd,0xb4c1,0xb4c5,0xb4c9,0xb4d3,0xb4e1,0xb4e2,0xb4e5,
|
||||
0xb4e6,0xb4e8,0xb4e9,0xb4ea,0xb4eb,0xb4f1,0xb4f3,0xb4f4,
|
||||
0xb4f5,0xb4f6,0xb4f7,0xb4f8,0xb4fa,0xb4fc,
|
||||
|
||||
0xb541,0xb542,0xb545,0xb549,0xb551,0xb553,0xb555,0xb557,
|
||||
0xb561,0xb562,0xb563,0xb565,0xb569,0xb56b,0xb56c,0xb571,
|
||||
0xb573,0xb574,0xb575,0xb576,0xb577,0xb57b,0xb57c,0xb57d,
|
||||
0xb581,0xb585,0xb589,0xb591,0xb593,0xb595,0xb596,0xb5a1,
|
||||
0xb5a2,0xb5a5,0xb5a9,0xb5aa,0xb5ab,0xb5ad,0xb5b0,0xb5b1,
|
||||
0xb5b3,0xb5b5,0xb5b7,0xb5b9,0xb5c1,0xb5c2,0xb5c5,0xb5c9,
|
||||
0xb5d1,0xb5d3,0xb5d5,0xb5d6,0xb5d7,0xb5e1,0xb5e2,0xb5e5,
|
||||
0xb5f1,0xb5f5,0xb5f7,0xb641,0xb642,0xb645,0xb649,0xb651,
|
||||
0xb653,0xb655,0xb657,0xb661,0xb662,0xb665,0xb669,0xb671,
|
||||
0xb673,0xb675,0xb677,0xb681,0xb682,0xb685,0xb689,0xb68a,
|
||||
0xb68b,0xb691,0xb693,0xb695,0xb697,0xb6a1,0xb6a2,0xb6a5,
|
||||
0xb6a9,0xb6b1,0xb6b3,0xb6b6,0xb6b7,0xb6c1,
|
||||
|
||||
0xb6c2,0xb6c5,0xb6c9,0xb6d1,0xb6d3,0xb6d7,0xb6e1,0xb6e2,
|
||||
0xb6e5,0xb6e9,0xb6f1,0xb6f3,0xb6f5,0xb6f7,0xb741,0xb742,
|
||||
0xb745,0xb749,0xb751,0xb753,0xb755,0xb757,0xb759,0xb761,
|
||||
0xb762,0xb765,0xb769,0xb76f,0xb771,0xb773,0xb775,0xb777,
|
||||
0xb778,0xb779,0xb77a,0xb77b,0xb77c,0xb77d,0xb781,0xb785,
|
||||
0xb789,0xb791,0xb795,0xb7a1,0xb7a2,0xb7a5,0xb7a9,0xb7aa,
|
||||
0xb7ab,0xb7b0,0xb7b1,0xb7b3,0xb7b5,0xb7b6,0xb7b7,0xb7b8,
|
||||
0xb7bc,0xb861,0xb862,0xb865,0xb867,0xb868,0xb869,0xb86b,
|
||||
0xb871,0xb873,0xb875,0xb876,0xb877,0xb878,0xb881,0xb882,
|
||||
0xb885,0xb889,0xb891,0xb893,0xb895,0xb896,0xb897,0xb8a1,
|
||||
0xb8a2,0xb8a5,0xb8a7,0xb8a9,0xb8b1,0xb8b7,0xb8c1,0xb8c5,
|
||||
0xb8c9,0xb8e1,0xb8e2,0xb8e5,0xb8e9,0xb8eb,
|
||||
|
||||
0xb8f1,0xb8f3,0xb8f5,0xb8f7,0xb8f8,0xb941,0xb942,0xb945,
|
||||
0xb949,0xb951,0xb953,0xb955,0xb957,0xb961,0xb965,0xb969,
|
||||
0xb971,0xb973,0xb976,0xb977,0xb981,0xb9a1,0xb9a2,0xb9a5,
|
||||
0xb9a9,0xb9ab,0xb9b1,0xb9b3,0xb9b5,0xb9b7,0xb9b8,0xb9b9,
|
||||
0xb9bd,0xb9c1,0xb9c2,0xb9c9,0xb9d3,0xb9d5,0xb9d7,0xb9e1,
|
||||
0xb9f6,0xb9f7,0xba41,0xba45,0xba49,0xba51,0xba53,0xba55,
|
||||
0xba57,0xba61,0xba62,0xba65,0xba77,0xba81,0xba82,0xba85,
|
||||
0xba89,0xba8a,0xba8b,0xba91,0xba93,0xba95,0xba97,0xbaa1,
|
||||
0xbab6,0xbac1,0xbae1,0xbae2,0xbae5,0xbae9,0xbaf1,0xbaf3,
|
||||
0xbaf5,0xbb41,0xbb45,0xbb49,0xbb51,0xbb61,0xbb62,0xbb65,
|
||||
0xbb69,0xbb71,0xbb73,0xbb75,0xbb77,0xbba1,0xbba2,0xbba5,
|
||||
0xbba8,0xbba9,0xbbab,0xbbb1,0xbbb3,0xbbb5,
|
||||
|
||||
0xbbb7,0xbbb8,0xbbbb,0xbbbc,0xbc61,0xbc62,0xbc65,0xbc67,
|
||||
0xbc69,0xbc6c,0xbc71,0xbc73,0xbc75,0xbc76,0xbc77,0xbc81,
|
||||
0xbc82,0xbc85,0xbc89,0xbc91,0xbc93,0xbc95,0xbc96,0xbc97,
|
||||
0xbca1,0xbca5,0xbcb7,0xbce1,0xbce2,0xbce5,0xbce9,0xbcf1,
|
||||
0xbcf3,0xbcf5,0xbcf6,0xbcf7,0xbd41,0xbd57,0xbd61,0xbd76,
|
||||
0xbda1,0xbda2,0xbda5,0xbda9,0xbdb1,0xbdb3,0xbdb5,0xbdb7,
|
||||
0xbdb9,0xbdc1,0xbdc2,0xbdc9,0xbdd6,0xbde1,0xbdf6,0xbe41,
|
||||
0xbe45,0xbe49,0xbe51,0xbe53,0xbe77,0xbe81,0xbe82,0xbe85,
|
||||
0xbe89,0xbe91,0xbe93,0xbe97,0xbea1,0xbeb6,0xbeb7,0xbee1,
|
||||
0xbf41,0xbf61,0xbf71,0xbf75,0xbf77,0xbfa1,0xbfa2,0xbfa5,
|
||||
0xbfa9,0xbfb1,0xbfb3,0xbfb7,0xbfb8,0xbfbd,0xc061,0xc062,
|
||||
0xc065,0xc067,0xc069,0xc071,0xc073,0xc075,
|
||||
|
||||
0xc076,0xc077,0xc078,0xc081,0xc082,0xc085,0xc089,0xc091,
|
||||
0xc093,0xc095,0xc096,0xc097,0xc0a1,0xc0a5,0xc0a7,0xc0a9,
|
||||
0xc0b1,0xc0b7,0xc0e1,0xc0e2,0xc0e5,0xc0e9,0xc0f1,0xc0f3,
|
||||
0xc0f5,0xc0f6,0xc0f7,0xc141,0xc142,0xc145,0xc149,0xc151,
|
||||
0xc153,0xc155,0xc157,0xc161,0xc165,0xc176,0xc181,0xc185,
|
||||
0xc197,0xc1a1,0xc1a2,0xc1a5,0xc1a9,0xc1b1,0xc1b3,0xc1b5,
|
||||
0xc1b7,0xc1c1,0xc1c5,0xc1c9,0xc1d7,0xc241,0xc245,0xc249,
|
||||
0xc251,0xc253,0xc255,0xc257,0xc261,0xc271,0xc281,0xc282,
|
||||
0xc285,0xc289,0xc291,0xc293,0xc295,0xc297,0xc2a1,0xc2b6,
|
||||
0xc2c1,0xc2c5,0xc2e1,0xc2e5,0xc2e9,0xc2f1,0xc2f3,0xc2f5,
|
||||
0xc2f7,0xc341,0xc345,0xc349,0xc351,0xc357,0xc361,0xc362,
|
||||
0xc365,0xc369,0xc371,0xc373,0xc375,0xc377,
|
||||
|
||||
0xc3a1,0xc3a2,0xc3a5,0xc3a8,0xc3a9,0xc3aa,0xc3b1,0xc3b3,
|
||||
0xc3b5,0xc3b7,0xc461,0xc462,0xc465,0xc469,0xc471,0xc473,
|
||||
0xc475,0xc477,0xc481,0xc482,0xc485,0xc489,0xc491,0xc493,
|
||||
0xc495,0xc496,0xc497,0xc4a1,0xc4a2,0xc4b7,0xc4e1,0xc4e2,
|
||||
0xc4e5,0xc4e8,0xc4e9,0xc4f1,0xc4f3,0xc4f5,0xc4f6,0xc4f7,
|
||||
0xc541,0xc542,0xc545,0xc549,0xc551,0xc553,0xc555,0xc557,
|
||||
0xc561,0xc565,0xc569,0xc571,0xc573,0xc575,0xc576,0xc577,
|
||||
0xc581,0xc5a1,0xc5a2,0xc5a5,0xc5a9,0xc5b1,0xc5b3,0xc5b5,
|
||||
0xc5b7,0xc5c1,0xc5c2,0xc5c5,0xc5c9,0xc5d1,0xc5d7,0xc5e1,
|
||||
0xc5f7,0xc641,0xc649,0xc661,0xc681,0xc682,0xc685,0xc689,
|
||||
0xc691,0xc693,0xc695,0xc697,0xc6a1,0xc6a5,0xc6a9,0xc6b7,
|
||||
0xc6c1,0xc6d7,0xc6e1,0xc6e2,0xc6e5,0xc6e9,
|
||||
|
||||
0xc6f1,0xc6f3,0xc6f5,0xc6f7,0xc741,0xc745,0xc749,0xc751,
|
||||
0xc761,0xc762,0xc765,0xc769,0xc771,0xc773,0xc777,0xc7a1,
|
||||
0xc7a2,0xc7a5,0xc7a9,0xc7b1,0xc7b3,0xc7b5,0xc7b7,0xc861,
|
||||
0xc862,0xc865,0xc869,0xc86a,0xc871,0xc873,0xc875,0xc876,
|
||||
0xc877,0xc881,0xc882,0xc885,0xc889,0xc891,0xc893,0xc895,
|
||||
0xc896,0xc897,0xc8a1,0xc8b7,0xc8e1,0xc8e2,0xc8e5,0xc8e9,
|
||||
0xc8eb,0xc8f1,0xc8f3,0xc8f5,0xc8f6,0xc8f7,0xc941,0xc942,
|
||||
0xc945,0xc949,0xc951,0xc953,0xc955,0xc957,0xc961,0xc965,
|
||||
0xc976,0xc981,0xc985,0xc9a1,0xc9a2,0xc9a5,0xc9a9,0xc9b1,
|
||||
0xc9b3,0xc9b5,0xc9b7,0xc9bc,0xc9c1,0xc9c5,0xc9e1,0xca41,
|
||||
0xca45,0xca55,0xca57,0xca61,0xca81,0xca82,0xca85,0xca89,
|
||||
0xca91,0xca93,0xca95,0xca97,0xcaa1,0xcab6,
|
||||
|
||||
0xcac1,0xcae1,0xcae2,0xcae5,0xcae9,0xcaf1,0xcaf3,0xcaf7,
|
||||
0xcb41,0xcb45,0xcb49,0xcb51,0xcb57,0xcb61,0xcb62,0xcb65,
|
||||
0xcb68,0xcb69,0xcb6b,0xcb71,0xcb73,0xcb75,0xcb81,0xcb85,
|
||||
0xcb89,0xcb91,0xcb93,0xcba1,0xcba2,0xcba5,0xcba9,0xcbb1,
|
||||
0xcbb3,0xcbb5,0xcbb7,0xcc61,0xcc62,0xcc63,0xcc65,0xcc69,
|
||||
0xcc6b,0xcc71,0xcc73,0xcc75,0xcc76,0xcc77,0xcc7b,0xcc81,
|
||||
0xcc82,0xcc85,0xcc89,0xcc91,0xcc93,0xcc95,0xcc96,0xcc97,
|
||||
0xcca1,0xcca2,0xcce1,0xcce2,0xcce5,0xcce9,0xccf1,0xccf3,
|
||||
0xccf5,0xccf6,0xccf7,0xcd41,0xcd42,0xcd45,0xcd49,0xcd51,
|
||||
0xcd53,0xcd55,0xcd57,0xcd61,0xcd65,0xcd69,0xcd71,0xcd73,
|
||||
0xcd76,0xcd77,0xcd81,0xcd89,0xcd93,0xcd95,0xcda1,0xcda2,
|
||||
0xcda5,0xcda9,0xcdb1,0xcdb3,0xcdb5,0xcdb7,
|
||||
|
||||
0xcdc1,0xcdd7,0xce41,0xce45,0xce61,0xce65,0xce69,0xce73,
|
||||
0xce75,0xce81,0xce82,0xce85,0xce88,0xce89,0xce8b,0xce91,
|
||||
0xce93,0xce95,0xce97,0xcea1,0xceb7,0xcee1,0xcee5,0xcee9,
|
||||
0xcef1,0xcef5,0xcf41,0xcf45,0xcf49,0xcf51,0xcf55,0xcf57,
|
||||
0xcf61,0xcf65,0xcf69,0xcf71,0xcf73,0xcf75,0xcfa1,0xcfa2,
|
||||
0xcfa5,0xcfa9,0xcfb1,0xcfb3,0xcfb5,0xcfb7,0xd061,0xd062,
|
||||
0xd065,0xd069,0xd06e,0xd071,0xd073,0xd075,0xd077,0xd081,
|
||||
0xd082,0xd085,0xd089,0xd091,0xd093,0xd095,0xd096,0xd097,
|
||||
0xd0a1,0xd0b7,0xd0e1,0xd0e2,0xd0e5,0xd0e9,0xd0eb,0xd0f1,
|
||||
0xd0f3,0xd0f5,0xd0f7,0xd141,0xd142,0xd145,0xd149,0xd151,
|
||||
0xd153,0xd155,0xd157,0xd161,0xd162,0xd165,0xd169,0xd171,
|
||||
0xd173,0xd175,0xd176,0xd177,0xd181,0xd185,
|
||||
|
||||
0xd189,0xd193,0xd1a1,0xd1a2,0xd1a5,0xd1a9,0xd1ae,0xd1b1,
|
||||
0xd1b3,0xd1b5,0xd1b7,0xd1bb,0xd1c1,0xd1c2,0xd1c5,0xd1c9,
|
||||
0xd1d5,0xd1d7,0xd1e1,0xd1e2,0xd1e5,0xd1f5,0xd1f7,0xd241,
|
||||
0xd242,0xd245,0xd249,0xd253,0xd255,0xd257,0xd261,0xd265,
|
||||
0xd269,0xd273,0xd275,0xd281,0xd282,0xd285,0xd289,0xd28e,
|
||||
0xd291,0xd295,0xd297,0xd2a1,0xd2a5,0xd2a9,0xd2b1,0xd2b7,
|
||||
0xd2c1,0xd2c2,0xd2c5,0xd2c9,0xd2d7,0xd2e1,0xd2e2,0xd2e5,
|
||||
0xd2e9,0xd2f1,0xd2f3,0xd2f5,0xd2f7,0xd341,0xd342,0xd345,
|
||||
0xd349,0xd351,0xd355,0xd357,0xd361,0xd362,0xd365,0xd367,
|
||||
0xd368,0xd369,0xd36a,0xd371,0xd373,0xd375,0xd377,0xd37b,
|
||||
0xd381,0xd385,0xd389,0xd391,0xd393,0xd397,0xd3a1,0xd3a2,
|
||||
0xd3a5,0xd3a9,0xd3b1,0xd3b3,0xd3b5,0xd3b7
|
||||
};
|
||||
@ -61,8 +61,6 @@ int thecore_init(int fps, HEARTFUNC heartbeat_func)
|
||||
if (!log_init() || !pid_init())
|
||||
return false;
|
||||
|
||||
GOST_Init();
|
||||
|
||||
thecore_heart = heart_new(1000000 / fps, heartbeat_func);
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -1,134 +0,0 @@
|
||||
/*
|
||||
(c) Copyright 2000-2002 convergence integrated media GmbH.
|
||||
(c) Copyright 2002 convergence GmbH.
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Written by Denis Oliver Kropp <dok@directfb.org>,
|
||||
Andreas Hundt <andi@fischlustig.de> and
|
||||
Sven Neumann <sven@convergence.de>.
|
||||
|
||||
Fast memcpy code was taken from xine (see below).
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Copyright (C) 2001 the xine project
|
||||
*
|
||||
* This file is part of xine, a unix video player.
|
||||
*
|
||||
* xine is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* xine is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
|
||||
*
|
||||
* These are the MMX/MMX2/SSE optimized versions of memcpy
|
||||
*
|
||||
* This code was adapted from Linux Kernel sources by Nick Kurshev to
|
||||
* the mplayer program. (http://mplayer.sourceforge.net)
|
||||
*
|
||||
* Miguel Freitas split the #ifdefs into several specialized functions that
|
||||
* are benchmarked at runtime by xine. Some original comments from Nick
|
||||
* have been preserved documenting some MMX/SSE oddities.
|
||||
* Also added kernel memcpy function that seems faster than glibc one.
|
||||
*
|
||||
*/
|
||||
|
||||
/* Original comments from mplayer (file: aclib.c) This part of code
|
||||
was taken by me from Linux-2.4.3 and slightly modified for MMX, MMX2,
|
||||
SSE instruction set. I have done it since linux uses page aligned
|
||||
blocks but mplayer uses weakly ordered data and original sources can
|
||||
not speedup them. Only using PREFETCHNTA and MOVNTQ together have
|
||||
effect!
|
||||
|
||||
From IA-32 Intel Architecture Software Developer's Manual Volume 1,
|
||||
|
||||
Order Number 245470:
|
||||
"10.4.6. Cacheability Control, Prefetch, and Memory Ordering Instructions"
|
||||
|
||||
Data referenced by a program can be temporal (data will be used
|
||||
again) or non-temporal (data will be referenced once and not reused
|
||||
in the immediate future). To make efficient use of the processor's
|
||||
caches, it is generally desirable to cache temporal data and not
|
||||
cache non-temporal data. Overloading the processor's caches with
|
||||
non-temporal data is sometimes referred to as "polluting the
|
||||
caches". The non-temporal data is written to memory with
|
||||
Write-Combining semantics.
|
||||
|
||||
The PREFETCHh instructions permits a program to load data into the
|
||||
processor at a suggested cache level, so that it is closer to the
|
||||
processors load and store unit when it is needed. If the data is
|
||||
already present in a level of the cache hierarchy that is closer to
|
||||
the processor, the PREFETCHh instruction will not result in any data
|
||||
movement. But we should you PREFETCHNTA: Non-temporal data fetch
|
||||
data into location close to the processor, minimizing cache
|
||||
pollution.
|
||||
|
||||
The MOVNTQ (store quadword using non-temporal hint) instruction
|
||||
stores packed integer data from an MMX register to memory, using a
|
||||
non-temporal hint. The MOVNTPS (store packed single-precision
|
||||
floating-point values using non-temporal hint) instruction stores
|
||||
packed floating-point data from an XMM register to memory, using a
|
||||
non-temporal hint.
|
||||
|
||||
The SFENCE (Store Fence) instruction controls write ordering by
|
||||
creating a fence for memory store operations. This instruction
|
||||
guarantees that the results of every store instruction that precedes
|
||||
the store fence in program order is globally visible before any
|
||||
store instruction that follows the fence. The SFENCE instruction
|
||||
provides an efficient way of ensuring ordering between procedures
|
||||
that produce weakly-ordered data and procedures that consume that
|
||||
data.
|
||||
|
||||
If you have questions please contact with me: Nick Kurshev:
|
||||
nickols_k@mail.ru.
|
||||
*/
|
||||
|
||||
/* mmx v.1 Note: Since we added alignment of destinition it speedups
|
||||
of memory copying on PentMMX, Celeron-1 and P2 upto 12% versus
|
||||
standard (non MMX-optimized) version.
|
||||
Note: on K6-2+ it speedups memory copying upto 25% and
|
||||
on K7 and P3 about 500% (5 times).
|
||||
*/
|
||||
|
||||
/* Additional notes on gcc assembly and processors: [MF]
|
||||
prefetch is specific for AMD processors, the intel ones should be
|
||||
prefetch0, prefetch1, prefetch2 which are not recognized by my gcc.
|
||||
prefetchnta is supported both on athlon and pentium 3.
|
||||
|
||||
therefore i will take off prefetchnta instructions from the mmx1
|
||||
version to avoid problems on pentium mmx and k6-2.
|
||||
|
||||
quote of the day:
|
||||
"Using prefetches efficiently is more of an art than a science"
|
||||
*/
|
||||
|
||||
#ifndef __WIN32__
|
||||
|
||||
#include <string.h>
|
||||
void *(*thecore_memcpy) (void * to, const void * from, size_t len) = memcpy;
|
||||
|
||||
#endif
|
||||
@ -266,7 +266,7 @@ socket_t socket_connect(const char* host, WORD port)
|
||||
return -1;
|
||||
}
|
||||
|
||||
thecore_memcpy((char* ) &server_addr.sin_addr, hp->h_addr, sizeof(server_addr.sin_addr));
|
||||
memcpy((char* ) &server_addr.sin_addr, hp->h_addr, sizeof(server_addr.sin_addr));
|
||||
}
|
||||
|
||||
server_addr.sin_family = AF_INET;
|
||||
|
||||
@ -1,338 +0,0 @@
|
||||
/*
|
||||
* Filename: tea.c
|
||||
* Description: TEA <20><>ȣȭ <20><><EFBFBD><EFBFBD>
|
||||
*
|
||||
* Author: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (aka. <20><><EFBFBD><EFBFBD>, Cronan), <20>ۿ<EFBFBD><DBBF><EFBFBD> (aka. myevan, <20><><EFBFBD>ڷ<EFBFBD>)
|
||||
*/
|
||||
#include "stdafx.h"
|
||||
|
||||
/*
|
||||
* TEA Encryption Module Instruction
|
||||
* Edited by <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> aka. <20><><EFBFBD><EFBFBD>, Cronan
|
||||
*
|
||||
* void tea_code(const DWORD sz, const DWORD sy, const DWORD *key, DWORD *dest)
|
||||
* void tea_decode(const DWORD sz, const DWORD sy, const DWORD *key, DWORD *dest)
|
||||
* 8<><38><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><>ȣ/<2F><>ȣȭ <20>Ҷ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ȴ<EFBFBD>. key <20><> 16 <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>.
|
||||
* sz, sy <20><> 8<><38><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
|
||||
*
|
||||
* int tea_decrypt(DWORD *dest, const DWORD *src, const DWORD *key, int size);
|
||||
* int tea_encrypt(DWORD *dest, const DWORD *src, const DWORD *key, int size);
|
||||
* <20>Ѳ<EFBFBD><D1B2><EFBFBD><EFBFBD><EFBFBD> 8 <20><><EFBFBD><EFBFBD>Ʈ <20>̻<EFBFBD><CCBB><EFBFBD> <20><>ȣ/<2F><>ȣȭ <20>Ҷ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>. <20><><EFBFBD><EFBFBD> size <20><>
|
||||
* 8<><38> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ƴϸ<C6B4> 8<><38> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<>⸦ "<22>÷<EFBFBD><C3B7><EFBFBD>" <20><>ȣȭ <20>Ѵ<EFBFBD>.
|
||||
*
|
||||
* ex. tea_code(pdwSrc[1], pdwSrc[0], pdwKey, pdwDest);
|
||||
* tea_decrypt(pdwDest, pdwSrc, pdwKey, nSize);
|
||||
*/
|
||||
|
||||
#define TEA_ROUND 32 // 32 <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD>, <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||||
#define DELTA 0x9E3779B9 // DELTA <20><> <20>ٲ<EFBFBD><D9B2><EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||||
|
||||
char tea_nilbuf[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
INLINE void tea_code(const DWORD sz, const DWORD sy, const DWORD *key, DWORD *dest)
|
||||
{
|
||||
register DWORD y = sy, z = sz, sum = 0;
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 1
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 2
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 3
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 4
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 5
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 6
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 7
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 8
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 9
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 10
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 11
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 12
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 13
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 14
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 15
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 16
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 17
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 18
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 19
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 20
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 21
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 22
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 23
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 24
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 25
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 26
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 27
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 28
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 29
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 30
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 31
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 32
|
||||
sum += DELTA;
|
||||
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
|
||||
|
||||
*(dest++) = y;
|
||||
*dest = z;
|
||||
}
|
||||
|
||||
INLINE void tea_decode(const DWORD sz, const DWORD sy, const DWORD *key, DWORD *dest)
|
||||
{
|
||||
register DWORD y = sy, z = sz, sum = DELTA * TEA_ROUND;
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 1
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 2
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 3
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 4
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 5
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 6
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 7
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 8
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 9
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 10
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 11
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 12
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 13
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 14
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 15
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 16
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 17
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 18
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 19
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 20
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 21
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 22
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 23
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 24
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 25
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 26
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 27
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 28
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 29
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 30
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 31
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 32
|
||||
sum -= DELTA;
|
||||
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
|
||||
|
||||
*(dest++) = y;
|
||||
*dest = z;
|
||||
}
|
||||
|
||||
int TEA_Encrypt(DWORD *dest, const DWORD *src, const DWORD * key, int size)
|
||||
{
|
||||
int i;
|
||||
int resize;
|
||||
|
||||
if (size % 8 != 0)
|
||||
{
|
||||
resize = size + 8 - (size % 8);
|
||||
memset((char *) src + size, 0, resize - size);
|
||||
}
|
||||
else
|
||||
resize = size;
|
||||
|
||||
for (i = 0; i < resize >> 3; i++, dest += 2, src += 2)
|
||||
tea_code(*(src + 1), *src, key, dest);
|
||||
|
||||
return (resize);
|
||||
}
|
||||
|
||||
int TEA_Decrypt(DWORD *dest, const DWORD *src, const DWORD * key, int size)
|
||||
{
|
||||
int i;
|
||||
int resize;
|
||||
|
||||
if (size % 8 != 0)
|
||||
resize = size + 8 - (size % 8);
|
||||
else
|
||||
resize = size;
|
||||
|
||||
for (i = 0; i < resize >> 3; i++, dest += 2, src += 2)
|
||||
tea_decode(*(src + 1), *src, key, dest);
|
||||
|
||||
return (resize);
|
||||
}
|
||||
|
||||
8682
libthecore/src/tea.s
8682
libthecore/src/tea.s
File diff suppressed because it is too large
Load Diff
@ -137,7 +137,7 @@ void trim_and_lower(const char * src, char * dest, size_t dest_size)
|
||||
// <20>տ<EFBFBD> <20><>ĭ <20>dz<EFBFBD> <20>ٱ<EFBFBD>
|
||||
while (*tmp)
|
||||
{
|
||||
if (!isnhspace(*tmp))
|
||||
if (!isspace(*tmp))
|
||||
break;
|
||||
|
||||
tmp++;
|
||||
@ -160,7 +160,7 @@ void trim_and_lower(const char * src, char * dest, size_t dest_size)
|
||||
// <20>ڿ<EFBFBD> <20><>ĭ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
--dest;
|
||||
|
||||
while (*dest && isnhspace(*dest) && len--)
|
||||
while (*dest && isspace(*dest) && len--)
|
||||
*(dest--) = '\0';
|
||||
}
|
||||
}
|
||||
@ -240,7 +240,7 @@ void parse_token(char *src, char *token, char *value)
|
||||
|
||||
for (tmp = src; *tmp && *tmp != ':'; tmp++)
|
||||
{
|
||||
if (isnhspace(*tmp))
|
||||
if (isspace(*tmp))
|
||||
continue;
|
||||
|
||||
*(token++) = LOWER(*tmp);
|
||||
@ -272,7 +272,7 @@ struct tm * tm_calc(const struct tm * curr_tm, int days)
|
||||
new_tm = *localtime(&time_s);
|
||||
}
|
||||
else
|
||||
thecore_memcpy(&new_tm, curr_tm, sizeof(struct tm));
|
||||
memcpy(&new_tm, curr_tm, sizeof(struct tm));
|
||||
|
||||
if (new_tm.tm_mon == 1)
|
||||
{
|
||||
|
||||
@ -1,345 +0,0 @@
|
||||
#include "stdafx.h"
|
||||
|
||||
#ifndef __FreeBSD__
|
||||
|
||||
/*
|
||||
* luau (Lib Update/Auto-Update): Simple Update Library
|
||||
* Copyright (C) 2003 David Eklund
|
||||
*
|
||||
* - This library is free software; you can redistribute it and/or -
|
||||
* - modify it under the terms of the GNU Lesser General Public -
|
||||
* - License as published by the Free Software Foundation; either -
|
||||
* - version 2.1 of the License, or (at your option) any later version. -
|
||||
* - -
|
||||
* - This library is distributed in the hope that it will be useful, -
|
||||
* - but WITHOUT ANY WARRANTY; without even the implied warranty of -
|
||||
* - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -
|
||||
* - Lesser General Public License for more details. -
|
||||
* - -
|
||||
* - You should have received a copy of the GNU Lesser General Public -
|
||||
* - License along with this library; if not, write to the Free Software -
|
||||
* - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -
|
||||
*/
|
||||
|
||||
/*
|
||||
* md5.h and md5.c are based off of md5hl.c, md5c.c, and md5.h from libmd, which in turn is
|
||||
* based off the FreeBSD libmd library. Their respective copyright notices follow:
|
||||
*/
|
||||
|
||||
/*
|
||||
* This code implements the MD5 message-digest algorithm.
|
||||
* The algorithm is due to Ron Rivest. This code was
|
||||
* written by Colin Plumb in 1993, no copyright is claimed.
|
||||
* This code is in the public domain; do with it what you wish.
|
||||
*
|
||||
* Equivalent code is available from RSA Data Security, Inc.
|
||||
* This code has been tested against that, and is equivalent,
|
||||
* except that you don't need to include two pages of legalese
|
||||
* with every copy.
|
||||
*/
|
||||
|
||||
/* ----------------------------------------------------------------------------
|
||||
* "THE BEER-WARE LICENSE" (Revision 42):
|
||||
* <phk@login.dkuug.dk> wrote this file. As long as you retain this notice you
|
||||
* can do whatever you want with this stuff. If we meet some day, and you think
|
||||
* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
|
||||
* ----------------------------------------------------------------------------
|
||||
*
|
||||
* $Id: md5.c,v 1.1.1.1 2004/04/02 05:11:38 deklund2 Exp $
|
||||
*
|
||||
*/
|
||||
|
||||
#include "xmd5.h"
|
||||
|
||||
#if __BYTE_ORDER == 1234
|
||||
#define byteReverse(buf, len) /* Nothing */
|
||||
#else
|
||||
void byteReverse(unsigned char *buf, unsigned longs);
|
||||
|
||||
/*
|
||||
* Note: this code is harmless on little-endian machines.
|
||||
*/
|
||||
void byteReverse(unsigned char *buf, unsigned longs)
|
||||
{
|
||||
uint32_t t;
|
||||
do {
|
||||
t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
|
||||
((unsigned) buf[1] << 8 | buf[0]);
|
||||
*(uint32_t *) buf = t;
|
||||
buf += 4;
|
||||
} while (--longs);
|
||||
}
|
||||
#endif /* ! __BYTE_ORDER == 1234 */
|
||||
|
||||
|
||||
|
||||
|
||||
char *
|
||||
lutil_md5_file (const char *filename, char *buf)
|
||||
{
|
||||
unsigned char buffer[BUFSIZ];
|
||||
MD5_CTX ctx;
|
||||
int f,i,j;
|
||||
|
||||
MD5Init(&ctx);
|
||||
|
||||
#ifndef __WIN32__
|
||||
f = open(filename,O_RDONLY);
|
||||
#else
|
||||
f = _open(filename, _O_RDONLY);
|
||||
#endif
|
||||
if (f < 0) return 0;
|
||||
while ((i = read(f,buffer,sizeof buffer)) > 0) {
|
||||
MD5Update(&ctx,buffer,i);
|
||||
}
|
||||
j = errno;
|
||||
close(f);
|
||||
errno = j;
|
||||
if (i < 0) return 0;
|
||||
return MD5End(&ctx, buf);
|
||||
}
|
||||
|
||||
char *
|
||||
lutil_md5_data (const unsigned char *data, unsigned int len, char *buf)
|
||||
{
|
||||
MD5_CTX ctx;
|
||||
|
||||
MD5Init(&ctx);
|
||||
MD5Update(&ctx,data,len);
|
||||
return MD5End(&ctx, buf);
|
||||
}
|
||||
|
||||
|
||||
/* Non-Interface Methods */
|
||||
|
||||
/* from md5hl.c */
|
||||
|
||||
char *
|
||||
MD5End(MD5_CTX *ctx, char *buf)
|
||||
{
|
||||
int i;
|
||||
unsigned char digest[MD5_HASHBYTES];
|
||||
static const char hex[]="0123456789abcdef";
|
||||
|
||||
if (!buf)
|
||||
buf = (char*)malloc(33);
|
||||
if (!buf)
|
||||
return 0;
|
||||
MD5Final(digest,ctx);
|
||||
for (i=0;i<MD5_HASHBYTES;i++) {
|
||||
buf[i+i] = hex[digest[i] >> 4];
|
||||
buf[i+i+1] = hex[digest[i] & 0x0f];
|
||||
}
|
||||
buf[i+i] = '\0';
|
||||
return buf;
|
||||
}
|
||||
|
||||
/*
|
||||
* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
|
||||
* initialization constants.
|
||||
*/
|
||||
void MD5Init(MD5_CTX *ctx)
|
||||
{
|
||||
ctx->buf[0] = 0x67452301;
|
||||
ctx->buf[1] = 0xefcdab89;
|
||||
ctx->buf[2] = 0x98badcfe;
|
||||
ctx->buf[3] = 0x10325476;
|
||||
|
||||
ctx->bits[0] = 0;
|
||||
ctx->bits[1] = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Update context to reflect the concatenation of another buffer full
|
||||
* of bytes.
|
||||
*/
|
||||
void MD5Update(MD5_CTX *ctx, unsigned char const *buf, unsigned len)
|
||||
{
|
||||
uint32_t t;
|
||||
|
||||
/* Update bitcount */
|
||||
|
||||
t = ctx->bits[0];
|
||||
if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t)
|
||||
ctx->bits[1]++; /* Carry from low to high */
|
||||
ctx->bits[1] += len >> 29;
|
||||
|
||||
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
|
||||
|
||||
/* Handle any leading odd-sized chunks */
|
||||
|
||||
if (t) {
|
||||
unsigned char *p = (unsigned char *) ctx->in + t;
|
||||
|
||||
t = 64 - t;
|
||||
if (len < t) {
|
||||
memcpy(p, buf, len);
|
||||
return;
|
||||
}
|
||||
memcpy(p, buf, t);
|
||||
byteReverse(ctx->in, 16);
|
||||
MD5Transform(ctx->buf, (uint32_t *) ctx->in);
|
||||
buf += t;
|
||||
len -= t;
|
||||
}
|
||||
/* Process data in 64-byte chunks */
|
||||
|
||||
while (len >= 64) {
|
||||
memcpy(ctx->in, buf, 64);
|
||||
byteReverse(ctx->in, 16);
|
||||
MD5Transform(ctx->buf, (uint32_t *) ctx->in);
|
||||
buf += 64;
|
||||
len -= 64;
|
||||
}
|
||||
|
||||
/* Handle any remaining bytes of data. */
|
||||
|
||||
memcpy(ctx->in, buf, len);
|
||||
}
|
||||
|
||||
/*
|
||||
* Final wrapup - pad to 64-byte boundary with the bit pattern
|
||||
* 1 0* (64-bit count of bits processed, MSB-first)
|
||||
*/
|
||||
void MD5Final(unsigned char digest[16], MD5_CTX *ctx)
|
||||
{
|
||||
unsigned count;
|
||||
unsigned char *p;
|
||||
|
||||
/* Compute number of bytes mod 64 */
|
||||
count = (ctx->bits[0] >> 3) & 0x3F;
|
||||
|
||||
/* Set the first char of padding to 0x80. This is safe since there is
|
||||
always at least one byte free */
|
||||
p = ctx->in + count;
|
||||
*p++ = 0x80;
|
||||
|
||||
/* Bytes of padding needed to make 64 bytes */
|
||||
count = 64 - 1 - count;
|
||||
|
||||
/* Pad out to 56 mod 64 */
|
||||
if (count < 8) {
|
||||
/* Two lots of padding: Pad the first block to 64 bytes */
|
||||
memset(p, 0, count);
|
||||
byteReverse(ctx->in, 16);
|
||||
MD5Transform(ctx->buf, (uint32_t *) ctx->in);
|
||||
|
||||
/* Now fill the next block with 56 bytes */
|
||||
memset(ctx->in, 0, 56);
|
||||
} else {
|
||||
/* Pad block to 56 bytes */
|
||||
memset(p, 0, count - 8);
|
||||
}
|
||||
byteReverse(ctx->in, 14);
|
||||
|
||||
/* Append length in bits and transform */
|
||||
((uint32_t *) ctx->in)[14] = ctx->bits[0];
|
||||
((uint32_t *) ctx->in)[15] = ctx->bits[1];
|
||||
|
||||
MD5Transform(ctx->buf, (uint32_t *) ctx->in);
|
||||
byteReverse((unsigned char *) ctx->buf, 4);
|
||||
memcpy(digest, ctx->buf, 16);
|
||||
memset((char *) ctx, 0, sizeof(ctx)); /* In case it's sensitive */
|
||||
}
|
||||
|
||||
/* The four core functions - F1 is optimized somewhat */
|
||||
|
||||
/* #define F1(x, y, z) (x & y | ~x & z) */
|
||||
#define F1(x, y, z) (z ^ (x & (y ^ z)))
|
||||
#define F2(x, y, z) F1(z, x, y)
|
||||
#define F3(x, y, z) (x ^ y ^ z)
|
||||
#define F4(x, y, z) (y ^ (x | ~z))
|
||||
|
||||
/* This is the central step in the MD5 algorithm. */
|
||||
#define MD5STEP(f, w, x, y, z, data, s) \
|
||||
( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
|
||||
|
||||
/*
|
||||
* The core of the MD5 algorithm, this alters an existing MD5 hash to
|
||||
* reflect the addition of 16 longwords of new data. MD5Update blocks
|
||||
* the data and converts bytes into longwords for this routine.
|
||||
*/
|
||||
void MD5Transform(uint32_t buf[4], uint32_t const in[16])
|
||||
{
|
||||
register uint32_t a, b, c, d;
|
||||
|
||||
a = buf[0];
|
||||
b = buf[1];
|
||||
c = buf[2];
|
||||
d = buf[3];
|
||||
|
||||
MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
|
||||
|
||||
MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
|
||||
|
||||
MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
|
||||
|
||||
MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
|
||||
|
||||
buf[0] += a;
|
||||
buf[1] += b;
|
||||
buf[2] += c;
|
||||
buf[3] += d;
|
||||
}
|
||||
|
||||
#endif // #ifndef __FreeBSD__
|
||||
Reference in New Issue
Block a user