Trang 1 trên tổng số 3 123 Cuối cùngCuối cùng
Từ 1 tới 10 trên tổng số 25 kết quả

Đề tài: Mã hóa văn bản

  1. #1
    Ngày gia nhập
    06 2008
    Nơi ở
    Nam Định
    Bài viết
    10

    Wink Mã hóa văn bản

    Xin chào các bạn!Cuối cùng thì lòng vòng mãi,nhoc mới được quyền gửi bài lên.Hic,sợ wa.Nhoc đang có một bài tập bằng ngôn ngữ C/C++.Theo đó,mình có thể tự xây dựng một phương pháp mã hóa,mã hóa một đoạn văn bản và giải mã đoạn văn bản đó.Dữ liệu vào,ra ở dạng file văn bản.Vậy các bạn có thể cho mình ý kiến về bài tập này với phương pháp mã hóa như thế nào là hay?với mỗi một phương pháp thì hay,dở của nó như thế nào được ko?
    Lấy người mình yêu hay lấy người yêu mình,đó là câu hỏi bất tận của nhân loại.---Ngạn ngữ Pháp---

  2. #2
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    mã hóa hay , mã hóa dở , mã hóa kém .... tất cả phụ thuộc vào mục đích sử dụng mã hóa để làm gì..
    tham khảo tại đây:
    http://forums.congdongcviet.com/show...ghlight=Caesar
    [bài năm trước ]
    None!

  3. #3
    Ngày gia nhập
    01 2008
    Nơi ở
    Rất nhiều sóng gió
    Bài viết
    447

    Trích dẫn Nguyên bản được gửi bởi nhocluoihoc Xem bài viết
    Xin chào các bạn!Cuối cùng thì lòng vòng mãi,nhoc mới được quyền gửi bài lên.Hic,sợ wa.Nhoc đang có một bài tập bằng ngôn ngữ C/C++.Theo đó,mình có thể tự xây dựng một phương pháp mã hóa,mã hóa một đoạn văn bản và giải mã đoạn văn bản đó.Dữ liệu vào,ra ở dạng file văn bản.Vậy các bạn có thể cho mình ý kiến về bài tập này với phương pháp mã hóa như thế nào là hay?với mỗi một phương pháp thì hay,dở của nó như thế nào được ko?
    Mình giúp bạn 1 í để mã hóa văn bản. Bảng mã ASCII có 128 kí tự trong đó có 95 kí tự đồ họa (hiện được, in được) là 32-127, và 5 kí tự phi đồ họa thường dùng trong văn bản là CR, NL (còn gọi là LF), NP (còn gọi là FF), HT, VT. Tất cả là 100 kí tự.

    Như thế ta có thể giả thiết văn bản dựa trên bảng mã 100 kí tự (thay vì 128 hay 256). Việc thu hẹp bảng mã có tính chất giống như việc nén: nó sẽ làm tăng độ an toàn của mật mã lên một chút.

    Sơ đồ mã hóa: ASCII ---(encode)--> mã 100 ---(encrypt)--> mã 100 ---(decode)---> ASCII

    Sơ đồ giải mã: ASCII ---(encode)--> mã 100 ---(decrypt)--> mã 100 ---(decode)---> ASCII


    Đối với bảng mã 100 kí tự, mật mã theo cơ số 10 hay cơ số 100 là tốt nhất. Đối với loại cơ số này thì 2 điều cốt yếu để được mật mã tốt là:

    1. Phải có CSPRNG tốt. (CSPRNG = cryptographically strong pseudo-random number generator, bộ sinh số giả ngẫu nhiên có độ an toàn mật mã.)

    2. Phải có thuật toán chuyển đổi tin cậy từ số giả ngẫu nhiên nhị phân thành thập phân. (Mọi CSPRNG tốt đều là nhị phân. Nếu chuyển số từ nhị phân sang thập phân mà lơ mơ thì số đang từ phân bố đều trở thành không đều, hỏng bét.)

    ad 1. Ví dụ một thuật toán mã hóa một số 64 bit (inbuf) và cho kết quả 64 bit (outbuf) dưới tác dụng của một khóa (key). Từ nó ta dễ dàng dựng được một CSPRNG. Thuật toán này lấy í tưởng từ RC5 và RC6.

    Code:
    typedef unsigned word32;
    #define ROUNDS 32
    
    void crypt64(word32 const inbuf[], word32 outbuf[], word32 const *key)
    {
        word32 A = *inbuf++, B = *inbuf;
        int m,n;
        for( m=0; m<2; m++ )
        {
            for(n=0; n < ROUNDS/8; n++, key += 2) 
            {
                B += key[0];
                A ^= B;
                A = _rotl(A, B*(2*B + 1) >> 27);
                A += key[1];
                B ^= A;
                B = _rotl(B, A*(2*A + 1) >> 27);
            }
            for(n=0; n < ROUNDS/8; n++, key += 2) 
            {
                A = _rotr(A, B*(2*B + 1) >> 27);
                A ^= B;
                B -= key[0];
                B = _rotr(B, A*(2*A + 1) >> 27);
                B ^= A;
                A -= key[1];
            }
        }
        
        *outbuf++ = B;
        *outbuf = A;
    }

    ad 2. Ví dụ một thuật toán chuyển đổi.

    Code:
    typedef unsigned word32;
    
    bool convert10(word32 x, word32& y)
    {
        if(x < 4000000000) { y = x/4; return true; }
        return false;
    }
    Cho crypt64() chạy liên tục sinh ra các số 32 bit nhị phân, đưa các số này qua convert10 nó sẽ lọc bỏ những số không dùng được và chuyển đổi mỗi số dùng được thành một số nguyên 9 chữ số thập phân. Trong 2^32 = khoảng 4.3 tỉ số nguyên 32 bit, ta chỉ dùng đúng 4 tỉ số, còn lại vứt.

    Ta sử dụng dãy số sinh ra để mã hóa văn bản nguồn bằng cách trộn từng chữ số (hay 2 chữ số) thập phân của nó với từng chữ số (hay 2 chữ số) của văn bản nguồn. Phép trộn có thể là cộng mod 10 (hay mod 100). Để giải mã thì dùng phép trừ mod 10 (hay mod 100).
    Đã được chỉnh sửa lần cuối bởi Ada : 10-06-2008 lúc 07:46 PM.

  4. #4
    Ngày gia nhập
    06 2008
    Nơi ở
    Nam Định
    Bài viết
    10

    Thực sự là nhoc đọc bài của Ada rất khó hiểu.Vì bài tập yêu cầu mã hóa văn bản đơn giản ở dạng text(*.txt),nên nhoc đã làm như sau(file đính kèm).Nhưng khi tạo ra file Encrypt.txt,nếu khóa dùng để giải mã là ký tự thì ko bị mất ký tự trong bản rõ,còn nếu khóa là số thì ký tự "t" sẽ bị mất.
    Attached Files Attached Files
    Lấy người mình yêu hay lấy người yêu mình,đó là câu hỏi bất tận của nhân loại.---Ngạn ngữ Pháp---

  5. #5
    Ngày gia nhập
    01 2008
    Nơi ở
    Rất nhiều sóng gió
    Bài viết
    447

    Mình đã xem qua code của nhoc:
    Code:
    		while(fin)
    		{
    		 fin.getline(line,n);
    
    		 for(int i=0;i<strlen(line);i++)
    		 {
    		 for(int j=0;j<strlen(key);j++)
    		 {
    		 line[i]=line[i]+key[j];
    		 }
    		 fout<<line[i];
    		 }
    		 if(fin.eof()!=0)
    		 {
    		 break;
    		 }
    		}
    và mình có nhận xét như thế này:

    1. Thực chất mã này mã hóa mọi kí tự của bản rõ (line) bằng cách cộng nó với một số, số ấy là tổng các kí tự của khóa (key). Bởi thế, một khóa N kí tự thật ra cũng chỉ có độ an toàn tương đương với khóa 1 kí tự, nghĩa là rất yếu.

    Giải pháp: tìm thuật toán khác.



    2. Bởi phép cộng nói trên là phép cộng mod 256 (thay vì mod số kí tự của bảng mã), nên trong bản mã sẽ có thể xuất hiện thêm những mã lạ (ngoài bảng mã), bản mã nói chung sẽ mất tính chất file văn bản và trở thành file nhị phân. Bởi thế, khi đọc bản mã (file nhị phân) ở chế độ văn bản, bạn có thể sẽ không đọc được trọn vẹn file mà quá trình đọc sẽ dừng khi gặp phải những mã đánh dấu hết file, dẫn đến hiện tượng "mất dữ liệu".

    Giải pháp:

    a/ Thay đổi đề bài từ "mã hóa văn bản" thành "mã hóa file nhị phân" và tương ứng, chữa code để nó mở mọi file ở chế độ nhị phân.

    hoặc:

    b/ Giữ nguyên đề bài và tìm một thuật toán mã hóa văn bản để giải đề bài. Trước hết, cần hiểu thật rõ 1 vấn đề cơ bản: sự khác nhau giữa văn bản và file nhị phân. Nói chung, mọi file đều là file nhị phân, nên câu hỏi chính xác ở đây là: khi nào thì một file nhị phân được xem là một file "văn bản"?
    Đã được chỉnh sửa lần cuối bởi Ada : 27-07-2008 lúc 08:17 PM.

  6. #6
    Ngày gia nhập
    06 2008
    Nơi ở
    Nam Định
    Bài viết
    10

    Mặc định Mã hóa văn bản

    Nhoc sẽ thử tìm một thuật toán khác thử xem.Khi phát hiện ra lỗi này,nhoc cũng đã nghĩ đến giải pháp khác.Nếu mã hóa văn bản bằng thuật toán Ceasar thì sao nhỉ?Còn xem theo link của XCross87 thì toàn bằng C# hết trơn.Mà nhoc thì đang tìm hiểu bằng C++ nên hiểu ko nổi.Thanks Ada rất nhiều!
    Lấy người mình yêu hay lấy người yêu mình,đó là câu hỏi bất tận của nhân loại.---Ngạn ngữ Pháp---

  7. #7
    Ngày gia nhập
    01 2008
    Nơi ở
    Rất nhiều sóng gió
    Bài viết
    447

    Trích dẫn Nguyên bản được gửi bởi nhocluoihoc Xem bài viết
    Nhoc sẽ thử tìm một thuật toán khác thử xem.Khi phát hiện ra lỗi này,nhoc cũng đã nghĩ đến giải pháp khác.Nếu mã hóa văn bản bằng thuật toán Ceasar thì sao nhỉ?
    Thuật toán trong code của nhoc chính là thuật toán Caesar. Chỉ khác duy nhất là: nhoc dùng khóa key, còn vua Caesar dùng khóa cố định là 3.

    Trích dẫn Nguyên bản được gửi bởi nhocluoihoc Xem bài viết
    Còn xem theo link của XCross87 thì toàn bằng C# hết trơn.Mà nhoc thì đang tìm hiểu bằng C++ nên hiểu ko nổi.Thanks Ada rất nhiều!
    Mình có code mã hóa văn bản viết bằng C++. Nhưng không dùng TC hay BC dịch được mà phải dùng GCC, MSVC hoặc ICC. Và nó hơi dài (khoảng 3000 dòng). Nếu nhoc muốn lấy, mình sẽ gửi lên.

  8. #8
    Ngày gia nhập
    06 2008
    Nơi ở
    Nam Định
    Bài viết
    10

    Trích dẫn Nguyên bản được gửi bởi Ada Xem bài viết
    Thuật toán trong code của nhoc chính là thuật toán Caesar. Chỉ khác duy nhất là: nhoc dùng khóa key, còn vua Caesar dùng khóa cố định là 3.



    Mình có code mã hóa văn bản viết bằng C++. Nhưng không dùng TC hay BC dịch được mà phải dùng GCC, MSVC hoặc ICC. Và nó hơi dài (khoảng 3000 dòng). Nếu nhoc muốn lấy, mình sẽ gửi lên.
    GCC ,MSCV hay ICC là gì?Ada giải thích giùm được ko?Ada gửi code đó lên để nhoc xem được ko?
    Lấy người mình yêu hay lấy người yêu mình,đó là câu hỏi bất tận của nhân loại.---Ngạn ngữ Pháp---

  9. #9
    Ngày gia nhập
    01 2008
    Nơi ở
    Rất nhiều sóng gió
    Bài viết
    447

    Trích dẫn Nguyên bản được gửi bởi nhocluoihoc Xem bài viết
    GCC ,MSCV hay ICC là gì? Ada giải thích giùm được ko?
    GCC là GNU Compiler Collection, bộ biên dịch nhiều ngôn ngữ trong bộ sưu tập phần mềm nguồn mở GNU, miễn phí. Có nhiều môi trường phát triển tích hợp GCC. Ví dụ, Code::Block (miễn phí), nhoc có thể download ở đây: http://www.codeblocks.org/

    MSVC là Microsoft Visual C++. ICC là Intel C++ Compiler. Cả 2 bộ biên dịch này đều có bản thương mại (phải trả tiền mua) và bản học tập (miễn phí), nhoc tự tìm nơi download nhé.

    Trích dẫn Nguyên bản được gửi bởi nhocluoihoc Xem bài viết
    Ada gửi code đó lên để nhoc xem được ko?
    Chờ mình vài phút. Mình lọc bỏ những đoạn không cần thiết rồi sẽ gửi lên.

  10. #10
    Ngày gia nhập
    01 2008
    Nơi ở
    Rất nhiều sóng gió
    Bài viết
    447

    C++ Code:
    1. /******************************************************************************
    2.  *  teta.h                                                                    *
    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.  ******************************************************************************/
    9.  
    10. // see teta-docs.txt for problem specification and algorithm description
    11.  
    12.  
    13. /*#############################################################################
    14.   #                                                                           #
    15.   #                                                                           #
    16.   #    SPEC                                                                   #
    17.   #                                                                           #
    18.   #                                                                           #
    19.   #############################################################################*/
    20.  
    21. #pragma once
    22.  
    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<cassert>
    31. #include<ctime>
    32. #endif
    33.  
    34.  
    35. #include<stdio.h>
    36. #include<stdlib.h>
    37.  
    38. #include<string>
    39. #include<iostream>
    40. #include<fstream>
    41. #include<iomanip>
    42. #include<vector>
    43. #include<map>
    44. #include<set>
    45. #include<algorithm>
    46.  
    47. #if defined( __INTEL_COMPILER )
    48. #include<mathimf.h>
    49. #elif defined( _MSC_VER )
    50. #include <cmath>
    51. #define round(x) double(int((x)))
    52.  
    53. #else
    54. #include<cmath>
    55. #endif
    56.  
    57. using namespace std;
    58.  
    59. ////////////////////////////////////////////////////////////////////////////////
    60. // Basics
    61.  
    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
    66.  
    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
    77.  
    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];
    88.  
    89. #define BASE               100
    90.  
    91. inline U32 lo32  (U64 x)   { return U32(x & 0xffffffff); }
    92. inline U32 hi32  (U64 x)   { return U32(x >> 32); }
    93. inline U64 mk64  (U32 L, U32 H)  { return (U64(H)<<32)|U64(L); }
    94.  
    95. inline U32 byteswap ( U32 x )
    96.                  { U32 u = ((x & 0xFF00FF00) >> 8) | (( x & 0x00FF00FF) << 8);
    97.                    return (u << 16) | (u >> 16); }
    98.  
    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 == 0x000102030405060708090a0b, then byteswap( y,x,3 ) yields
    102.         //         y == 0x0b0a09080706050403020100
    103.  
    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
    110.  
    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)); }
    114.  
    115. inline double sqr   (double x) { return x*x; }
    116.  
    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
    120.  
    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    2nd input (key) stream of the B100 stream encryptor and authenticator.
    141.  
    142.  
    143. void crypt128setup      (); // constructs subsitution tables for
    144.                             // the reference implementation and
    145.                             // optimized implementation(s) of crypt128
    146.  
    147. // crypt128--reference implementation
    148. void crypt128encryptYXZ_ref   (V128& Y, V128 const& X, V160 const& Z);
    149.                               // encrypt X to Y using key Z
    150. void crypt128decryptYXZ_ref   (V128& Y, V128 const& X, V160 const& Z);
    151.                               // decrypt X to Y using key Z
    152.  
    153. // crypt128--optimized implementation
    154. void crypt128expandTZ   (V2176& T, V160 const& Z);
    155.                         // expands key Z into subkeys T
    156. void crypt128encryptYXT_opt   (V128& Y, V128 const& X, V2176 const& T);
    157.                         // encrypt X to Y using expanded key T
    158.  
    159. // crypt160--reference implementation
    160. void crypt160expandTZ   (V4608& T, V256 const& Z);
    161.                         // expands key Z into subkeys T
    162. void crypt160encryptYXT_ref   (V160& Y, V160 const& X, V4608 const& T);
    163.                         // encrypt X to Y using expanded key T
    164.  
    165. // crypt160--optimized implementations
    166. void crypt160encryptYXT_opt1  (V160& Y, V160 const& X, V4608 const& T);
    167.                         // encrypt X to Y using expanded key T
    168. void crypt160encryptYXT_opt2  (V160& Y, V160 const& X, V4608 const& T);
    169.                         // encrypt X to Y using expanded key T
    170.  
    171. inline
    172. void crypt160encryptYXT (V160& Y, V160 const& X, V4608 const& T)
    173. {                        // encrypts X to Y using subkeys T
    174.     crypt160encryptYXT_opt2 ( Y, X, T );
    175. }
    176.  
    177. void uhash160expandTS   (V320 &T, V160 const& S);
    178.                         // expands key S into subkeys T, **updates** T
    179.  
    180. void uhash160hashYZT    (V160& Y, V256 const& Z, V320 const& T);
    181.                         // hash Z to Y from previous hash Y using subkeys T,
    182.                         // ** updates ** Y
    183.  
    184. void b100h64expandTZ    (V3200& T, V256 const& Z);
    185.                         // expands key Z into subkeys T
    186.  
    187. void b100h64hashYXUWT   (V64& Y, V64 const& X, U8 const U, U32 const W2, V3200 const& 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[]
    191.  
    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 ?
    197.  
    198. U64    c128hash64       (V160 const& 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.
    201.  
    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
    206.  
    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
    216.  
    217. ////////////////////////////////////////////////////////////////////////////////
    218. // Template instantiations
    219.  
    220. #include "teta-tmpl.h"
    221. template class UsgRng<U8,C160toU8buffer>;
    222. typedef        UsgRng<U8,C160toU8buffer> U8prng;
    223.  
    224. template class UsgRng<U16,C160toU16buffer>;
    225. typedef        UsgRng<U16,C160toU16buffer> U16prng;
    226.  
    227. template class UsgRng<U32>;
    228. typedef        UsgRng<U32> U32prng;
    229.  
    230. template class UsgRng<U64>;
    231. typedef        UsgRng<U64> U64prng;
    232.  
    233. template class UsgRng<U32,C128toU32buffer,Crypt128prng>;
    234. typedef        UsgRng<U32,C128toU32buffer,Crypt128prng> U32cipher;
    235.  
    236. typedef        U32prng  U32trng;
    237.  
    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!
    263.  
    264.     U8      operator()  () {return randB100();}
    265.  
    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();
    271.  
    272.     void    seed        (V160 const& z, U64 iv);
    273.  
    274.     // TODO: consider adding more constructors and variants of seed()
    275.  
    276.     static
    277.     void    test        ();
    278.  
    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'.
    283.  
    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()
    290.  
    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. };
    296.  
    297. ////////////////////////////////////////////////////////////////////////////////
    298. class B100mac
    299. {
    300. public:
    301.     void    initialize  (V160 const& z);// Initialize with primary key z
    302.  
    303.     void    hashB100    (U8 u, U32 w2); // Hash u using w2 (2 chars) from a
    304.                                         // keystream
    305.  
    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().
    310.  
    311.     U64     getMac      () const;       // Returns the MAC value
    312.  
    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();
    319.  
    320. private:
    321.     V3200   _tkey;      // array of 100 subkeys derived from the key, used as
    322.                         // the T parameter to b100h64hash().
    323.  
    324.     V2176   _pdfxkey;   // expanded key of the pad derivation function
    325.  
    326.     V64     _hash;      // Current hash value
    327.     V64     _mac;       // Final MAC value
    328. };
    329.  
    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.
    339.  
    340. public:
    341.     B100streamAuthEncryptor(Controller *c, Keybase *kb);
    342.  
    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     (istream& ps, ostream& cs);
    351.     void        decrypt     (istream& cs, ostream& ps);
    352.  
    353.     static void test        ();
    354.  
    355. private:
    356.     Controller  *_controller;   // The assoc. controller. Call it if needed
    357.     Keybase     *_keybase;      // The assoc. keybase. Call it if needed
    358.  
    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:
    363.  
    364. (1) Each Pchar/Cchar that is an Xchar/Ychar maps to itself.
    365.  
    366. (2) Each Pchar/Cchar that is not an Xchar/Ychar maps to:
    367.     (2a) a Xchar/Ychar substitute, i.e. Xchar/Ychar in 100 chars above; or
    368.     (2b) NUL, if it is to be deleted in the encoded Xchar/Ychar text
    369.        before encoding to B100.
    370.  
    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.
    373.  
    374. Notes
    375. - Xchar contains DEL so a char maps to DEL if it does not have a meaningful
    376. substitute, by spec and by rule (3).
    377.  
    378. - DEL maps to itself in P->X by rule (1), and maps to NUL in C->Y by rule (2b) .
    379.  
    380. - NUL maps to DEL in P->X by rule (3), and maps to itself in C->Y by rule (2b).
    381.  
    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 maps to NUL in C->Y.
    387.  
    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.
    390.  
    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.
    395.  
    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.
    400.  
    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
    407.  
    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   (string& p, string const& c);
    412.     using           B100prng::seed;
    413. };
    414.  
    415. ////////////////////////////////////////////////////////////////////////////////
    416. class Hash160
    417. {
    418.  
    419. public:
    420.     Hash160();
    421.  
    422.     void        initialize  (U64 salt);
    423.                     // The salt is used primarily as the key for uhash160.
    424.  
    425.     void        hashBlock   (V256 const& 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<32.
    429.  
    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().
    434.  
    435.     V160 const& getHash     () const;
    436.                     // returns the final hash value
    437.  
    438.     V160 const& 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));
    445.  
    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. };
    454.  
    455. ////////////////////////////////////////////////////////////////////////////////
    456. struct Keyinfo
    457. {
    458.     V160            key;
    459.  
    460.     U64             keyid;  // The hash value of the key
    461.  
    462.     U64             salt;   // The salt that was used to hash the key
    463.  
    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
    468.  
    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. };
    473.  
    474. ////////////////////////////////////////////////////////////////////////////////
    475. class Keybase
    476. {
    477. public:
    478.     explicit
    479.     Keybase         (string const& keyfilename); // Load keybase from file
    480.  
    481.     ~Keybase        ();     // Save this keybase to the original file
    482.  
    483.     Keyinfo const * selectKey  (U64 const& keyid) const;
    484.                     // Select certain key to decrypt / verify MAC.
    485.                     // Return NULL if such key not found in this keybase
    486.  
    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.
    492.  
    493.     static void     test();
    494.  
    495. private:
    496.     vector<Keyinfo> _keyinfos;
    497.     map<U64,int>    _keyidx;
    498.     string          _keyfilename;
    499.  
    500.     Keyinfo const&  genKey      ();  // generate a key and add it to _keyinfos
    501.                                 // returns reference to the just-added key
    502.  
    503.     void            loadKeys    (string const& keyfilename);
    504.     void            saveKeys    (string const& keyfilename);
    505. };
    506.  
    507. ////////////////////////////////////////////////////////////////////////////////
    508. class Controller
    509. {
    510. public:
    511.     Controller();
    512.     ~Controller ();
    513. };
    514.  
    515.  
    516. ////////////////////////////////////////////////////////////////////////////////
    517. // Statistical & DSP stuffs
    518.  
    519. struct Statistic
    520. {
    521.     Statistic(vector<double> const& data);
    522.     string image(void);
    523.     int         _n;
    524.     double      _mu;
    525.     double      _sigma;
    526.     double      _max, _min;
    527. };
    528.  
    529. double quartile     (double p, vector<double> const& 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.
    537.  
    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
    541.  
    542. double  entropy     ( map<int,int> & f );
    543.     // (Shannon) entropy [bits] of **each** symbol given its frequency
    544.     // distribution, f[]
    545.  
    546. double  entropy     ( int const s[], int len );
    547.     // entropy [bits] of the array 's' of length 'len'
    548.  
    549. double  entropy     ( U8 ss[], int len );
    550.     // entropy [bits] of the signal sample 'ss' of length 'len',
    551.     // consisting of 2nd differential of the usclock() values,
    552.     // i.e. jitters of latency of usclock().
    553.  
    554.  
    555. ////////////////////////////////////////////////////////////////////////////////
    556. // Microsecond clock
    557. //
    558. // Implemented by high-resolution performance counter (HRPC)
    559. // which is available on Win32 only
    560.  
    561. #include<windows.h>
    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
    569.  
    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.
    577.  
    578.  
    579. ////////////////////////////////////////////////////////////////////////////////
    580. // Global variables
    581.  
    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;
    589.  
    590. extern U8 const     P_AESsbox    [256];
    591. extern U8 const     P_affineSqrt2[256];
    592. extern U8 const     P_affineSqrt3[256];
    593.  
    594. ////////////////////////////////////////////////////////////////////////////////
    595. // Inlines
    596.  
    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)
    603.  
    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 ) & ((1<<NBITS)-1);
    617.     _bitbuf >>= NBITS;
    618.     return r;
    619. }
    620.  
    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
    649.  
    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)*0x51EB851F) >> 5; // optimized
    657.  
    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
    661.  
    662.     //U32 c = _digbuf % BASE; // unoptimized
    663.     U32 c = _digbuf - d*BASE; // half-optimized
    664.     _digbuf = d;
    665.     _digbuflen--;
    666.     return U8(c);
    667. }
    668.  
    669. //------------------------------------------------------------------------------
    670. inline
    671. U32 B100prng::rand4B100()
    672. {
    673.     // Performance == randB100() + 2 cc/char
    674.  
    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)*0x51EB851F) >> 5; // optimized
    682.  
    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. }
    690.  
    691. //------------------------------------------------------------------------------
    692. inline
    693. void b100h64hashYXUWT (V64& Y, V64 const& X, U8 const U, U32 const W2,
    694.                               V3200 const& 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     &0xFF]);
    699.     Y[1] = p32(X[1] + U32(U),T[(W2>> 8)&0xFF]);
    700. }
    701.  
    702.  
    703. //------------------------------------------------------------------------------
    704. inline
    705. void B100mac::hashB100    ( U8 u, U32 w2 )
    706. {
    707.     b100h64hashYXUWT ( _hash, _hash, u, w2, _tkey );
    708. }
    Đã được chỉnh sửa lần cuối bởi Ada : 27-07-2008 lúc 11:48 PM.

Các đề tài tương tự

  1. Dịch vụ gửi hàng hóa đi Australia, gửi hàng hóa đi France, gửi hàng hóa đi Germany, gửi hàng hóa đi Janpan giá rẻ.
    Gửi bởi sales5ttico trong diễn đàn Giới thiệu website, sản phẩm của bạn
    Trả lời: 1
    Bài viết cuối: 30-07-2014, 02:51 PM
  2. Kỹ thuật C++ Chuẩn hóa nội dung văn bản-Xử lý văn bản
    Gửi bởi minius92 trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 0
    Bài viết cuối: 08-10-2012, 10:06 PM
  3. lại vấn đề mã hóa văn bản
    Gửi bởi honey trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 3
    Bài viết cuối: 07-08-2008, 07:46 AM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn