Trang chủ Kỹ Thuật Số Mã hóa văn bản

Mã hóa văn bản

  1. / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  2.  *  teta.h                                                                    *

    Bạn đang đọc: Mã hóa văn bản

  3. * *

  4. * ASCII text stream integrated encryptor – authenticator *

  5. * in EtA ( Encrypt-then-Authenticate ) mode *

  6. * * * This program is only a DEMO of cryptographic algorithms. *

  7. * * * Do NOT use it for serious purposes. *

  8. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /

  10. / / see teta-docs.txt for problem specification and algorithm description

  13. / * # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

  14. # #

  15. # #

  16. # SPEC #

  17. # #

  18. # #

  19. # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # * /

  21. # pragma once

  23. / / msvc specifics

  24. # if defined ( _MSC_VER )

  25. # define __MSC__

  26. / / Disable throw, precedence, size_t -> int, ptrdiff -> u32 warnings

  27. # pragma warning ( disable : 4290 4554 4267 )

  28. # endif

  29. # ifdef __MSC__

  30. #include

  31. #include

  32. # endif

  35. #include

  36. #include

  38. #include

  39. #include

  40. #include

  41. #include

  42. #include

  43. #include

  44. #include

  45. #include

  47. # if defined ( __INTEL_COMPILER )

  48. #include

  49. # elif defined ( _MSC_VER )

  50. #include

  51. # define round ( x ) double ( int ( ( x ) ) )

  53. # else

  54. #include

  55. # endif

  57. using namespace std;

  59. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  60. / / Basics

  62. typedef unsigned char       U8;  / / PROBLEM : char may have more than 8 bits

  63. typedef unsigned short      U16; / / PROBLEM : short may have more than 16 bits

  64. typedef unsigned long       U32; / / PROBLEM : long may have more than 32 bits

  65. typedef unsigned long long  U64; / / PROBLEM : long long may have more than 64 bits

  67. # define V64LEN 2 / / 32 – bit words

  68. # define V96LEN 3 / / 32 – bit words

  69. # define V128LEN 4 / / 32 – bit words

  70. # define V160LEN 5 / / 32 – bit words

  71. # define V256LEN 8 / / 32 – bit words

  72. # define V320LEN 10 / / 32 – bit words

  73. # define V1024LEN 32 / / 32 – bit words

  74. # define V2176LEN 68 / / 32 – bit words

  75. # define V4608LEN 144 / / 32 – bit words

  76. # define V3200LEN 100 / / 32 – bit words

  78. typedef U32                 V64  [V64LEN];

  79. typedef U32                 V96  [V96LEN];

  80. typedef U32                 V128 [V128LEN];

  81. typedef U32                 V160 [V160LEN];

  82. typedef U32                 V256 [V256LEN];

  83. typedef U32                 V320 [V320LEN];

  84. typedef U32                 V1024[V1024LEN];

  85. typedef U32                 V2176[V2176LEN];

  86. typedef U32                 V4608[V4608LEN];

  87. typedef U32                 V3200[V3200LEN];

  89. # define BASE 100

  91. inline U32 lo32  (U64 x)   { return U32(x và 0 xffffffff); }

  92. inline U32 hi32  (U64 x)   { return U32(x >> 32); }

  93. inline U64 mk64  (U32 L, U32 H)  { return (U64(H)< <32)|U64(L); }

  95. inline U32 byteswap ( U32 x )

  96.                  { U32 u = ((x và 0 xFF00FF00) >> 8) | (( x và 0x00 FF00FF) < < 8);

  97.                    return (u < < 16) | (u >> 16); }

  99. void byteswap( U32 y[], U32 const x[], int len );

  100.         / / reverse bytes of x and store result to y

  101.         / / e. g. if x = = 0x000102030405060708090 a0b, then byteswap ( y, x, 3 ) yields

  102.         / / y = = 0x0 b0a09080706050403020100

  104. / / gcc 3. x translates std :: _rotl ( ), std :: _rotr ( ) to library function calls

  105. / / instead of machine opcodes rol and ror => catastrophic performance .

  106. # ifdef __GNUC__

  107. # define _rotl ( x, r ) ( ( ( x ) < < ( r ) ) | ( ( x ) >> ( 32 – ( r ) ) ) )

  108. # define _rotr ( x, r ) ( ( ( x ) >> ( r ) ) | ( ( x ) < < ( 32 - ( r ) ) ) )

  109. # endif

  111. / / _rotl ( ), _rotl ( ) are only 32 bit, but we need 64 – bit version too

  112. inline U64  rotl64  (U64 x, int r) { return (x < < r)|(x >> (64-r)); }

  113. inline U64  rotr64  (U64 x, int r) { return (x >> r)|(x < < (64-r)); }

  115. inline double sqr   (double x) { return x*x; }

  117. # define LOG2 0.69314718055994530941723212145818 / / log ( 2 )

  118. # define ILOG2 1.4426950408889634073599246810019 / / 1 / log ( 2 )

  119. inline double log2  (double x) { return log(x)*ILOG2; } / / logarithm of x in base 2

  121. / / Conventional naming :

  122. / /

  123. / / X, Y Input, output block of the same size. For a block cipher, X is plain

  124. / / block, Y is cipherblock. For a block cipher-based hash function, X

  125. / / is the previous state of hash value, Y is the new state of hash value .

  126. / /

  127. / / Z Input block that is usually longer than of X, Y .

  128. / / For a block cipher it is primary key. For block cipher-based hash function

  129. / / it is the hashed data .

  130. / /

  131. / / S Input block, used by the keyed hash function uhash64 as the primary key .

  132. / / It changes every block hashed .

  133. / /

  134. / / T Expanded key, ie. array of subkeys. For uhash64 it is same type as Z .

  135. / /

  136. / / U Input ( plain ) stream of the b100 stream encryptor and authenticator .

  137. / /

  138. / / V Output ( cipher ) stream of the b100 stream encryptor .

  139. / /

  140. / / W 2 nd input ( key ) stream of the B100 stream encryptor and authenticator .

  143. void crypt128setup      (); / / constructs subsitution tables for

  144.                             / / the reference implementation and

  145.                             / / optimized implementation ( s ) of crypt128

  147. / / crypt128–reference implementation

  148. void crypt128encryptYXZ_ref   (V128và Y, V128 constvà X, V160 constvà Z);

  149.                               / / encrypt X to Y using key Z

  150. void crypt128decryptYXZ_ref   (V128và Y, V128 constvà X, V160 constvà Z);

  151.                               / / decrypt X to Y using key Z

  153. / / crypt128–optimized implementation

  154. void crypt128expandTZ   (V2176và T, V160 constvà Z);

  155.                         / / expands key Z into subkeys T

  156. void crypt128encryptYXT_opt   (V128và Y, V128 constvà X, V2176 constvà T);

  157.                         / / encrypt X to Y using expanded key T

  159. / / crypt160–reference implementation

  160. void crypt160expandTZ   (V4608và T, V256 constvà Z);

  161.                         / / expands key Z into subkeys T

  162. void crypt160encryptYXT_ref   (V160và Y, V160 constvà X, V4608 constvà T);

  163.                         / / encrypt X to Y using expanded key T

  165. / / crypt160–optimized implementations

  166. void crypt160encryptYXT_opt1  (V160và Y, V160 constvà X, V4608 constvà T);

  167.                         / / encrypt X to Y using expanded key T

  168. void crypt160encryptYXT_opt2  (V160và Y, V160 constvà X, V4608 constvà T);

  169.                         / / encrypt X to Y using expanded key T

  171. inline

  172. void crypt160encryptYXT (V160và Y, V160 constvà X, V4608 constvà T)

  173. {                        / / encrypts X to Y using subkeys T

  174.     crypt160encryptYXT_opt2 ( Y, X, T );

  175. }

  177. void uhash160expandTS   (V320 vàT, V160 constvà S);

  178.                         / / expands key S into subkeys T, * * updates * * T

  180. void uhash160hashYZT    (V160và Y, V256 constvà Z, V320 constvà T);

  181.                         / / hash Z to Y from previous hash Y using subkeys T ,

  182.                         / / * * updates * * Y

  184. void b100h64expandTZ    (V3200và T, V256 constvà Z);

  185.                         / / expands key Z into subkeys T

  187. void b100h64hashYXUWT   (V64và Y, V64 constvà X, U8 const U, U32 const W2, V3200 constvà T);

  188.                         / / hash U to Y from previous hash X using 2 consecutive

  189.                         / / chars ( W2 ) of a not necessarily secret random stream

  190.                         / / and a table of secret subkeys T [ ]

  192. inline U32 q32          (U32 x)   {return x*(2*x+1);}          / / used by crypt160

  193. inline U64 q64          (U64 x)   {return x*(2*x+1);}          / / used by crypt64

  194. inline U32 p32          (U32 x, U32 y) {return y*(2*x+1) + x;} / / used by b100h64

  195. inline U32 f32          (U32 x, U32 y) {return y*(2*x+0x80000001) + x;} / / unused ?

  196. inline U64 p64          (U64 x, U64 y) {return y*(2*x+1) + x;} / / unused ?

  198. U64    c128hash64       (V160 constvà Z, U64 salt);

  199.                         / / Using 160 – bit key Z, encrypts 64 – bit salt ( zero-padded to 128 – bit ) ,

  200.                         / / returns 64 – bit low half of the cipherblock .

  202. U64 muluh_shift         (U64 n, U64 m, int sh1,int sh2);

  203.                         / / Computes ( m * ( n >> sh1 ) ) >> ( sh2 + 64 ), a particular case

  204.                         / / of Granlund-Montgomery formula

  205.                         / / to perform unsigned division by multiplication

  207. class Hash160;          / / 160 – bit cryptographic hash function

  208. class B100prng;         / / Base100 keystream generator

  209. class B100mac;          / / Base100 stream MAC calculator

  210. class B100streamAuthEncryptor; / / Integrated base100 stream en – / de-cryptor

  211.                         / / and MAC calculator / verifier in an EtA mode ;

  212.                         / / Integrated plainstream substitutor, X en – / de-coder ,

  213.                         / / cipherstream en – / de-formatter and Y en – / de-coder

  214. class Keybase;          / / Manages keys, provides key-related services

  215. class Controller;       / / Controls user I / O

  217. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  218. / / Template instantiations

  220. # include ” teta-tmpl. h “

  221. template class UsgRng;

  222. typedef        UsgRng U8prng;

  224. template class UsgRng;

  225. typedef        UsgRng U16prng;

  227. template class UsgRng;

  228. typedef        UsgRng U32prng;

  230. template class UsgRng;

  231. typedef        UsgRng U64prng;

  233. template class UsgRng;

  234. typedef        UsgRng U32cipher;

  236. typedef        U32prng  U32trng;

  238. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  239. class B100prng : protected U32cipher

  240.                         / / a template Bxxprng < > would be more general, but much

  241.                         / / more complicated, with bitstream splitting etc .

  242. {

  243. public:

  244.     U8      randB100    (); / / Returns pseudo-random b100 char ( i. e. of 0 .. 99 )

  245.     U32     rand4B100   (); / / Returns 4 consecutive chars of the pseudo-random

  246.                             / / b100 stream in a 4 – byte sliding buffer ,

  247.                             / / in low-first order, i. e. if the stream is

  248.                             / / a1 a2 a3 a4 a5 … then :

  249.                             / / First call returns a1 xx xx xx ( xx = garbage )

  250.                             / / Second call returns a2 a1 xx xx

  251.                             / / Third call returns a3 a2 a1 xx

  252.                             / / Fourth call returns a4 a3 a2 a1

  253.                             / / Fifth call returns a5 a4 a3 a2

  254.                             / / k-th call returns a [ k ] a [ k-1 ] a [ k-2 ] a [ k-3 ]

  255.     / / Usage :

  256.     / / This class is used specifically by B100streamAuthEncryptor to

  257.     / / encrypt and to feed the B100mac algorithm with upto 4 keystreams

  258.     / / ( 128 – bit MAC ) .

  259.     / / Encrypt-only and 32 – bit MAC mode may use randB100 ( ) to save ~ 2 cc / char .

  260.     / / 64 -, 96 -, 128 – bit MAC modes must use rand4B100 ( ) .

  261.     / / Use either randB100 ( ) or rand4B100 ( ). If both are needed, create two

  262.     / / B100prng instances !

  264.     U8      operator()  () {return randB100();}

  266.     / / only one constructor is provided because this class is used only via

  267.     / / protected inheritance by B100streamAuthEncryptor, which does not have

  268.     / / enough infos at its construction time to call more meaningful base class

  269.     / / constructors .

  270.     B100prng();

  272.     void    seed        (V160 constvà z, U64 iv);

  274.     / / TODO : consider adding more constructors and variants of seed ( )

  276.     static

  277.     void    test        ();

  279. private:

  280.     static const int  NDIGITS   =3;       / / N ,

  281.     static const int  NBITS     =20;      / / K ,

  282.     static const U64  MAXMULT   =1000000; / / M, described in ‘ Algorithms ‘ .

  284.     U64     _bitbuf;     / / ( Secondary ) buffer of bits

  285.     int     _bitbuflen;  / / Number of bits remaining in it

  286.     U32     _digbuf;     / / ( Tertiary ) buffer of B-ary digits, 0 .. M-1

  287.     int     _digbuflen;  / / Number of digits remaining in it, 0 .. N

  288.     U32     _o4digbuf;   / / ( Quaternary ) sliding buffer of 4 consecutive output

  289.                          / / chars for rand4B100 ( )

  291. public: / / The following should be private. They are made public for testing only

  292.     U32     randU20     (); / / Splits the 160 – bit output of the underlying prng

  293.                          / / in 20 – bit nibbles and returns them, one by one ,

  294.                          / / in low-first order

  295. };

  297. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  298. class B100mac

  299. {

  300. public:

  301.     void    initialize  (V160 constvà z);/ / Initialize with primary key z

  303.     void    hashB100    (U8 u, U32 w2); / / Hash u using w2 ( 2 chars ) from a

  304.                                         / / keystream

  306.     void    finalize    (U64 nonce);    / / Computes final MAC and store it

  307.                                         / / to another internal variable that can

  308.                                         / / be read later by getMAC ( ). MACing may

  309.                                         / / continue even after finalize ( ) .

  311.     U64     getMac      () const;       / / Returns the MAC value

  313. protected:

  314.     / / only one constructor is provided because this class is used only via

  315.     / / protected inheritance by B100streamAuthEncryptor, which does not have

  316.     / / enough infos at its construction time to call more meaningful base class

  317.     / / constructors .

  318.     B100mac();

  320. private:

  321.     V3200   _tkey;      / / array of 100 subkeys derived from the key, used as

  322.                         / / the T parameter to b100h64hash ( ) .

  324.     V2176   _pdfxkey;   / / expanded key of the pad derivation function

  326.     V64     _hash;      / / Current hash value

  327.     V64     _mac;       / / Final MAC value

  328. };

  330. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  331. class B100streamAuthEncryptor: protected B100prng, protected B100mac

  332. {

  333.     / / Reemphasize : The keystream for this EtA class is seeded by a 32 – bit nonce ,

  334.     / / uses an internal 32 – bit counter. The cipherstream is MACed by a 32 – bit

  335.     / / nonce and produces 64 – bit MAC with forge probability of 2 * * – 50 ( regardless

  336.     / / of message length ). So this class may be used to encrypt + authenticate

  337.     / / upto 2 * * 32 messages, each upto 2 * * 32 chars long with the max forgeability

  338.     / / of 2 * * – 18 .

  340. public:

  341.     B100streamAuthEncryptor

    (

    Controller *c, Keybase *kb);

  343.     / / Plainstream * should * be open in binary mode because only binary mode

  344.     / / guarantee decrypt ( encrypt ( s ) ) = = s exactly regardless of environments

  345.     / / where decrypt ( ) and encrypt ( ) are executed. In text mode, the equality

  346.     / / is guaranteed only if encrypt ( ) and decrypt ( ) are executed in the same

  347.     / / environment .

  348.     / /

  349.     / / Cipherstream may be open in either mode .

  350.     void        encrypt     (istreamvà ps, ostreamvà cs);

  351.     void        decrypt     (istreamvà cs, ostreamvà ps);

  353.     static void test        ();

  355. private:

  356.     Controller  *_controller;   / / The assoc. controller. Call it if needed

  357.     Keybase     *_keybase;      / / The assoc. keybase. Call it if needed

  359. / *

  360. The substitution process shall be represented by a function P -> X, the process

  361. of deformatting the ‘ ciphertext ‘ of a ‘ ciphertext_file ‘ shall be presented by a

  362. function C -> Y :

  364. ( 1 ) Each Pchar / Cchar that is an Xchar / Ychar map to itself .

  366. ( 2 ) Each Pchar / Cchar that is not an Xchar / Ychar map to :

  367. ( 2 a ) a Xchar / Ychar substitute, i. e. Xchar / Ychar in 100 chars above ; or

  368. ( 2 b ) NUL, if it is to be deleted in the encoded Xchar / Ychar text

  369. before encoding to B100 .

  371. ( 3 ) Nothing of plaintext may be ignored ( deleted ), everything, even NUL ,

  372. must survive in the encoded Xchar text as itself or as a Xchar substitute .

  374. Notes

  375. – Xchar contains DEL so a char map to DEL if it does not have a meaningful

  376. substitute, by spec and by rule ( 3 ) .

  378. – DEL map to itself in P -> X by rule ( 1 ), and map to NUL in C -> Y by rule ( 2 b ) .

  380. – NUL map to DEL in P -> X by rule ( 3 ), and map to itself in C -> Y by rule ( 2 b ) .

  382. – Any other char of the ciphertext, including any format_effector and

  383. logcomctrl_char which were inserted by the formatter, shall be deleted by the

  384. deformatter before encoding to Ychar. ( This is not a rule, just a consequence

  385. of the fundamental requirement that ciphertext must be decryptable. ) Therefore ,

  386. every such char map to NUL in C -> Y .

  388. – The range of the function P -> X contains exactly 100 chars ; the range of

  389. the function C -> Y contains exactly 100 Ychars + NUL = = 101 chars .

  391. – The function P -> X will be used to implement ( as a single array ) an

  392. automated

  393. . P -> B100, i. e. substitutor + Xencoder ,

  394. . B100 -> P, i. e. Xdecoder .

  396. – The deformatter’s function will be used to implement ( as a single array )

  397. an automated

  398. . C -> B100, i. e. deformatter’s ciphertext-processing part + Yencoder

  399. . B100 -> C, i. e. Ydecoder + formatter’s ciphertext-generating part .

  401. * /

  402.     static void     constructCode   (U8(*PCtoXY)(U8),U8 PCtoB100[256], U8 B100toPC[BASE+1]);

  403.     static U8       ansiToX         (U8 c); / / substitutor’s map P -> X

  404.     static U8       ansiToY         (U8 c); / / deformatter’s map C -> Y

  405.     U8              encryptChar     (U8 x); / / return encrypted char or NUL

  406.     U8              decryptChar     (U8 y); / / return decrypted char or NUL

  408. / / the following should be private. They are public only for testing

  409. public:

  410.     void            encryptString   (char *cs, char const* ps, int len);

  411.     void            decryptString   (stringvà p, string constvà c);

  412.     using           B100prng::seed;

  413. };

  415. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  416. class Hash160

  417. {

  419. public:

  420.     Hash160();

  422.     void        initialize  (U64 salt);

  423.                     / / The salt is used primarily as the key for uhash160 .

  425.     void        hashBlock   (V256 constvà Z, int len=sizeof(V256));

  426.                     / / hash block Z into internal variable

  427.                     / / although there is parameter ‘ len ‘, Z must be a

  428.                     / / zero-padded 256 – bit data block even if len <3 2 .

  430.     void        finalize    ();

  431.                     / / computes final hash value and store it to another

  432.                     / / internal variable, which can be read by getHash ( ) .

  433.                     / / Hashing may continue even after finalize ( ) .

  435.     V160 constvà getHash     () const;

  436.                     / / returns the final hash value

  438.     V160 constvà operator()(void const *z, int len, U64 salt = 0);

  439.                     / / hash byte string z of ‘ len ‘ bytes using ‘ salt ‘ and return

  440.                     / / the hash value. Example of use :

  441.                     / / char s [ 1000 ] ;

  442.                     / / …

  443.                     / / Hash64 hash ;

  444.                     / / V160 h = hash ( s, sizeof ( s ), time ( NULL ) ) ;

  446. protected:

  447.     V160        _chash;   / / current hash val of the underlying crypt160

  448.     V160        _uhash;   / / current hash val of the accompanying uhash160

  449.     V160        _hash;    / / final ( combined ) hash value

  450.     size_t      _datalen; / / number of bytes hashed so far

  451.     V4608       _crypt160xkey; / / expanded key of the underlying crypt160 …

  452.     V320        _uhash160xkey; / / … and the accompanying uhash160

  453. };

  455. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  456. struct Keyinfo

  457. {

  458.     V160            key;

  460.     U64             keyid;  / / The hash value of the key

  462.     U64             salt;   / / The salt that was used to hash the key

  464.     U64             nUsed;  / / Number of times the key is used to encrypt / create

  465.                             / / MAC. This number is used as the nonce for the next

  466.                             / / message authenticated under the key, or as the seed

  467.                             / / for the next message encrypted under the key

  469.     bool            isActive; / / Keys are never deleted and may be always used

  470.                             / / to decrypt / verify mac. Furthermore, when a key is

  471.                             / / _active_ it can be used to encrypt / create mac .

  472. };

  474. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  475. class Keybase

  476. {

  477. public:

  478.     explicit

  479.     Keybase         (string constvà keyfilename); / / Load keybase from file

  481.     ~Keybase        ();     / / Save this keybase to the original file

  483.     Keyinfo const * selectKey  (U64 constvà keyid) const;

  484.                     / / Select certain key to decrypt / verify MAC .

  485.                     / / Return NULL if such key not found in this keybase

  487.     Keyinfo obtainKey  ();

  488.                     / / Obtain a suitable key to encrypt / create MAC .

  489.                     / / If this keybase finds no suitable key, it generates one .

  490.                     / / If it finds out a key, it increment the seed and the nonce

  491.                     / / before returning the key info .

  493.     static void     test();

  495. private:

  496.     vector _keyinfos;

  497.     map    _keyidx;

  498.     string          _keyfilename;

  500.     Keyinfo constvà  genKey      ();  / / generate a key and add it to _keyinfos

  501.                                 / / returns reference to the just-added key

  503.     void            loadKeys    (string constvà keyfilename);

  504.     void            saveKeys    (string constvà keyfilename);

  505. };

  507. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  508. class Controller

  509. {

  510. public:

  511.     Controller();

  512.     ~Controller ();

  513. };

  516. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  517. / / Statistical và DSP stuffs

  519. struct Statistic

  520. {

  521.     Statistic(vector constvà data);

  522.     string image(void);

  523.     int         _n;

  524.     double      _mu;

  525.     double      _sigma;

  526.     double      _max, _min;

  527. };

  529. double quartile     (double p, vector constvà sorted_data);

  530.                         / / Determines p-quartile ( octile, decile, … ) of the

  531.                         / / sorted_data, where sorted_data is viewed as a

  532.                         / / multiset of floats ; it must be already sorted .

  533. / / Example : quartile ( 0.25, v ), is a float q dividing v into 3 partitions

  534. / / v0, v01, v1 concisting of floats smaller than q, equaling to q and

  535. / / larger than q respectively, such that | v0 | < = 0.25 | v | and | v1 | < = 0.75 | v | .

  536. / / If v01 = = empty, then every number in ( max v0, min v1 ) can be the q .

  538. void    haardwt     (int y[], int const x[], int len);

  539.     / / Haar discrete wavelet transform of signal x [ ] to spectrum y [ ] ,

  540.     / / len must be 2 * * n

  542. double  entropy     ( map và f );

  543.     / / ( Shannon ) entropy [ bits ] of * * each * * symbol given its frequency

  544.     / / distribution, f [ ]

  546. double  entropy     ( int const s[], int len );

  547.     / / entropy [ bits ] of the array ‘ s ‘ of length ‘ len ‘

  549. double  entropy     ( U8 ss[], int len );

  550.     / / entropy [ bits ] of the signal sample ‘ ss ‘ of length ‘ len ‘ ,

  551.     / / consisting of 2 nd differential of the usclock ( ) values ,

  552.     / / i. e. jitters of latency of usclock ( ) .

  555. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  556. / / Microsecond clock

  557. / /

  558. / / Implemented by high-resolution performance counter ( HRPC )

  559. / / which is available on Win32 only

  561. #include

  562. / / ——————————————————————————

  563. extern double HRPC_FRQ;         / / [ Hz ] HRPC frequency

  564. extern double HRPC_PRD;         / / [ s ] HRPC period, ie. span of 1 tick

  565. extern double MACH_FRQ;         / / [ Hz ] Machine ( CPU ) frequency

  566. extern double MACH_PRD;         / / [ s ] Machine ( CPU ) period, ie. span of 1 cc

  567. extern double CC_PER_TICK;      / / [ cc / ct ] # CPU cc per HRPC tick

  568. extern double UCLK_LATENCY;     / / [ s ] ( mean of ) uclock latency

  570. LONGLONG    usclock ();         / / [ ct ] current value of the HRPC counter

  571. void        hrpcInit();         / / initialization, call it once at the begining

  572. void        rampup  ( float t );/ / Ramping up for about t seconds .

  573.     / / There’re many reasons to do so, including :

  574.     / / – initial page faults ,

  575.     / / – initial cache misses ,

  576.     / / – initial CPU’s frequency which may not be the full MACH_FRQ .

  579. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  580. / / Global variables

  582. extern U32trng      g_u32trng;

  583. extern U8prng       g_u8prng;

  584. extern U16prng      g_u16prng;

  585. extern U32prng      g_u32prng;

  586. extern U64prng      g_u64prng;

  587. extern Crypt128prng g_crypt128prng;

  588. extern Crypt160prng g_crypt160prng;

  590. extern U8 const     P_AESsbox    [256];

  591. extern U8 const     P_affineSqrt2[256];

  592. extern U8 const     P_affineSqrt3[256];

  594. / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

  595. / / Inlines

  597. / / ——————————————————————————

  598. inline U32 B100prng::randU20() / / Inline saves only 1-2 cc / char and even makes it slower

  599.                         / / in some previous versions. Be careful !

  600. {

  601.     / / Performance : brutto 70 cc / char

  602.     / / ( each U20 is equivalent to 3 chars )

  604.     if(_bitbuflen < NBITS)

  605.         / / if _bitbuf is U64, it can load 32 bits once so if ( … ) will suffice .

  606.         / / But if _bitbuf was U32 then it could load 8 bits once and there would

  607.         / / be while ( … ) .

  608.     {

  609.         / / dequeue a U32 from the low end of the primary buffer and enqueue the

  610.         / / 32 bits to the high end of _bitbuf

  611.         _bitbuf |= U64(U32cipher::rand()) < < _bitbuflen;

  612.         _bitbuflen += 32;

  613.     }

  614.     / / dequeue 20 bits from the low end of _bitbuf

  615.     _bitbuflen -= NBITS;

  616.     U32 r = U32( _bitbuf ) và ((1<

  617.     _bitbuf >> = NBITS;

  618.     return r;

  619. }

  621. / / ——————————————————————————

  622. inline

  623. U8 B100prng::randB100()

  624. {

  625.     / / Performance :

  626.     / /

  627.     / / – The result is extremely sensitive to benchmark parameters ,

  628.     / / i. e. number of repetitions etc. Use consistent parameters or the results

  629.     / / won’t be comparable !

  630.     / /

  631.     / / – All benchmarks are made with crypt128encryptYXT_opt ( ) .

  632.     / /

  633.     / / – The unit is [ cc / char ]. Throughput of crypt128 must be converted from

  634.     / / cc / byte to cc / char ; e. g. 73.5 cc / byte is equivalent to

  635.     / / 73.5 * ( 20/8 ) * 2 * * 20 / ( 3 * 1E6 ) = 73.5 * 0.874 = 64 cc / char

  636.     / /

  637.     / / Item ICC MSVC GCC

  638.     / / = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  639.     / / 1. Unoptimized : 1 div + 1 mod

  640.     / / brutto : —- —- —-

  641.     / / 2. Optimized : 2 mul

  642.     / / brutto : 86 —- 106

  643.     / / crypt128, converted 64 80

  644.     / / netto : 22 —- 26

  645.     / /

  646.     / / => For 32 – bit arithmetic MSVC, GCC may have already optimized code .

  647.     / / The trick of replacing div-mod with multiplication is effective with 64 – bit

  648.     / / arithmetics only

  650.     if(!_digbuflen)

  651.     {

  652.         while((_digbuf = randU20()) > = MAXMULT);

  653.         _digbuflen = NDIGITS;

  654.     }

  655.     / / U32 d = _digbuf / BASE ; / / unoptimized

  656.     U32 d = hi32(U64(_digbuf)*0x51 EB851F) >> 5; / / optimized

  658.     / / The following line is to divide by 100 using 64 – bit arithmetic .

  659.     / / Do NOT delete ! Reserved for future use :

  660.     / / U64 d = muluh_shift ( _buffer, 2951479051793528259ULL, 2,2 ) ; / / optimized

  662.     / / U32 c = _digbuf % BASE ; / / unoptimized

  663.     U32 c = _digbuf – d*BASE; / / half-optimized

  664.     _digbuf = d;

  665.     _digbuflen–;

  666.     return U8(c);

  667. }

  669. / / ——————————————————————————

  670. inline

  671. U32 B100prng::rand4B100()

  672. {

  673.     / / Performance = = randB100 ( ) + 2 cc / char

  675.     if(!_digbuflen)

  676.     {

  677.         while((_digbuf = randU20()) > = MAXMULT);

  678.         _digbuflen = NDIGITS;

  679.     }

  680.     / / U32 d = _digbuf / BASE ; / / unoptimized

  681.     U32 d = hi32(U64(_digbuf)*0x51 EB851F) >> 5; / / optimized

  683.     / / U32 c = _digbuf % BASE ; / / unoptimized

  684.     U32 c = _digbuf – d*BASE; / / half-optimized

  685.     _digbuf = d;

  686.     _digbuflen–;

  687.     _o4digbuf = (_o4digbuf >> 8) | (c < < 24);

  688.     return _o4digbuf;

  689. }

  691. / / ——————————————————————————

  692. inline

  693. void b100h64hashYXUWT (V64và Y, V64 constvà X, U8 const U, U32 const W2,

  694.                               V3200 constvà T)

  695.                         / / hash U to Y from previous hash X using 2 bytes W2

  696.                         / / from a random stream and a table of subkeys T [ ]

  697. {

  698.     Y[0] = p32(X[0] + U32(U),T[ W2     và0 xFF]);

  699.     Y[1] = p32(X[1] + U32(U),T[(W2>> 8)và0 xFF]);

  700. }

  703. / / ——————————————————————————

  704. inline

  705. void B100mac::hashB100    ( U8 u, U32 w2 )

  706. {

  707.     b100h64hashYXUWT ( _hash, _hash, u, w2, _tkey

    )

    ;

  708. }

Mã hóa văn bản
Bài viết liên quan
Sửa máy giặt
Bài Mới Nhất
Hotline 24/7: O984.666.352
Alternate Text Gọi ngay