Develop and Download Open Source Software

プロジェクト・ナニ屋

Browse Subversion Repository

/[naniya]/branches/mty-makai/mty.c

Diff of /branches/mty-makai/mty.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2 by chapuni, Fri Mar 2 07:03:17 2007 UTC revision 6 by chapuni, Fri Mar 2 18:15:39 2007 UTC
# Line 25  Line 25 
25  #include <sys/time.h>  #include <sys/time.h>
26  #include <assert.h>  #include <assert.h>
27  #include <ctype.h>  #include <ctype.h>
28    #include <stdint.h>
29  #include <stdio.h>  #include <stdio.h>
30  #include <stdlib.h>  #include <stdlib.h>
31  #include <string.h>  #include <string.h>
# Line 32  Line 33 
33  #include "crypt64.h"  #include "crypt64.h"
34  #include "dt4.h"  #include "dt4.h"
35    
36    #ifdef MMX
37    
38    #define N_STRIDE 6
39    typedef uint64_t        WS_T;
40    typedef uint32_t        ALU_T;
41    
42    #else
43    
44    #define N_STRIDE 7
45    typedef unsigned        WS_T __attribute__ ((mode(V4SI)));
46    typedef uint32_t        ALU_T;
47    
48    #endif
49    
50    #define N_ALU (sizeof(WS_T) / sizeof(ALU_T))
51    #define ALU_BITS (8 * sizeof(ALU_T))
52    
53  /* 鍵転置 PC1 */  /* 鍵転置 PC1 */
54  static int const tr_pc1[8][7] =  static int const tr_pc1[8][7] =
55  {  {
# Line 60  static int const tr_fp[64 + 2] = Line 78  static int const tr_fp[64 + 2] =
78  };  };
79    
80  /* 1ビット分 */  /* 1ビット分 */
81  struct SLICE  typedef union SLICE
82  {  {
83    unsigned long a[2];    ALU_T         a[N_ALU];       /* C で扱いやすいサイズ */
84  };    WS_T          w;                      /* エンコードで扱うサイズ */
85    } SLICE;
86    
87  /* crypt64() が喰うパラメータ */  /* crypt64() が喰うパラメータ */
88  struct PARAM  struct PARAM
89  {  {
90    struct SLICE lr[2][32];    SLICE lr[2][32];
91    struct SLICE t[32];    SLICE t[32];
92    struct SLICE hit[10][64];    SLICE hit[10][64];
93    struct SLICE hiti[10][26];    SLICE hiti[10][26];
94  };  };
95    
96  /* 鍵はLR と、そのコピーが必要 */  /* 鍵はLR と、そのコピーが必要 */
97  struct KEY  struct KEY
98  {  {
99    struct SLICE k[2][2][28];    SLICE k[2][2][28];
100  };  };
101    
102  /* 漢字クラス表 */  /* 漢字クラス表 */
# Line 349  key_set64(struct KEY *key64, Line 368  key_set64(struct KEY *key64,
368                    unsigned vk,                    unsigned vk,
369                    unsigned sk)                    unsigned sk)
370  {  {
371    int i;    int i, j;
372    if (!((vk | sk) & 0x7F))    if (!((vk | sk) & 0x7F))
373          return;          return;
374    
375    for (i = 0; i < 7; i++)    for (i = 0; i < 7; i++)
376          {          {
377            if (n == 7 && i < 6) continue;            if (n == 7 && i < N_STRIDE) continue;
378            if (sk & (1 << i))            if (sk & (1 << i))
379                  {                  {
380                    /* セット */                    /* セット */
# Line 363  key_set64(struct KEY *key64, Line 382  key_set64(struct KEY *key64,
382                    if (o < 28)                    if (o < 28)
383                          {                          {
384                            assert(o >= 0);                            assert(o >= 0);
385                            key64->k[0][0][o].a[0]                            for (j = 0; j < N_ALU; j++)
386                                  = key64->k[0][0][o].a[1]                                  key64->k[0][0][o].a[j]
387                                  = key64->k[0][1][o].a[0]                                  = key64->k[0][1][o].a[j]
388                                  = key64->k[0][1][o].a[1]                                    = -!!(k & (1 << i));
                                 = -!!(k & (1 << i));  
389                          }                          }
390                    else                    else
391                          {                          {
392                            assert(o >= 28);                            assert(o >= 28);
393                            assert(o < 56);                            assert(o < 56);
394                            key64->k[1][0][o - 28].a[0]                            for (j = 0; j < N_ALU; j++)
395                                  = key64->k[1][0][o - 28].a[1]                                  key64->k[1][0][o - 28].a[j]
396                                  = key64->k[1][1][o - 28].a[0]                                    = key64->k[1][1][o - 28].a[j]
397                                  = key64->k[1][1][o - 28].a[1]                                    = -!!(k & (1 << i));
                                 = -!!(k & (1 << i));  
398                          }                          }
399                  }                  }
400            else if (vk & (1 << i))            else if (vk & (1 << i))
# Line 387  key_set64(struct KEY *key64, Line 404  key_set64(struct KEY *key64,
404                    if (o < 28)                    if (o < 28)
405                          {                          {
406                            assert(o >= 0);                            assert(o >= 0);
407                            key64->k[0][0][o].a[0]                            key64->k[0][0][o].w
408                                  = key64->k[0][0][o].a[1]                                  = key64->k[0][1][o].w
409                                  = key64->k[0][1][o].a[0]                                  = ~key64->k[0][0][o].w;
                                 = key64->k[0][1][o].a[1]  
                                 = ~key64->k[0][0][o].a[0];  
410                          }                          }
411                    else                    else
412                          {                          {
413                            assert(o >= 28);                            assert(o >= 28);
414                            assert(o < 56);                            assert(o < 56);
415                            key64->k[1][0][o - 28].a[0]                            key64->k[1][0][o - 28].w
416                                  = key64->k[1][0][o - 28].a[1]                                  = key64->k[1][1][o - 28].w
417                                  = key64->k[1][1][o - 28].a[0]                                  = ~key64->k[1][0][o - 28].w;
                                 = key64->k[1][1][o - 28].a[1]  
                                 = ~key64->k[1][0][o - 28].a[0];  
418                          }                          }
419                  }                  }
420          }          }
# Line 479  key_inc(int n) Line 492  key_inc(int n)
492          return 0;          return 0;
493    else if (n == 7)    else if (n == 7)
494          {          {
495              /* 最後のバイト */
496              if (N_STRIDE == 7)
497                    return 0;
498    
499            key[7] = (key[7] + 64) & 127;            key[7] = (key[7] + 64) & 127;
500            if (key[7]) return 1;            if (key[7]) return 1;
501            else return 0;            else return 0;
# Line 836  translate(unsigned char *ptr, Line 853  translate(unsigned char *ptr,
853   *   *
854   */   */
855    
856    #ifdef MMX
857    #define C(c,i,j,o) (*(signed char *)((c) + (loo - crypt64_sta) + los[6 * (i) + (j) + (o)]))
858    #else
859    #define C(c,i,j,o) (*(signed long *)((c) + (loo - crypt64_sta) + los[6 * (i) + (j) + (o)]))
860    #endif
861    
862  void  void
863  set_salt(signed char *code,  set_salt(signed char *code,
864                   unsigned char const *k)                   unsigned char const *k)
# Line 862  set_salt(signed char *code, Line 885  set_salt(signed char *code,
885            for (j = 0; j < 6; j++)            for (j = 0; j < 6; j++)
886                  {                  {
887  #if DEBUG>=2  #if DEBUG>=2
888                    printf("Salt %d:%d %+3d:%+3d",                    //printf("Salt %d:%d %+3d:%+3d",
889                      printf("Salt %d:%d %08lX:%08lX",
890                                   i, j,                                   i, j,
891                                   code[loo - crypt64_sta + los[6 * i + j     ]],                                   C(code, i, j,  0),
892                                   code[loo - crypt64_sta + los[6 * i + j + 24]]);                                   C(code, i, j, 24));
893  #endif  #endif
894                  if (s & (1 << j))                  if (s & (1 << j))
895                    {                    {
896                          code[loo - crypt64_sta + los[6 * i + j     ]] = 8 * ((4 * i + j + 15) & 31) - 128;                          C(code, i, j,  0) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
897                          code[loo - crypt64_sta + los[6 * i + j + 24]] = 8 * ((4 * i + j -  1) & 31) - 128;                          C(code, i, j, 24) = sizeof(WS_T) * (((4 * i + j -  1) & 31) - 16);
898                    }                    }
899                  else                  else
900                    {                    {
901                          code[loo - crypt64_sta + los[6 * i + j     ]] = 8 * ((4 * i + j -  1) & 31) - 128;                          C(code, i, j,  0) = sizeof(WS_T) * (((4 * i + j -  1) & 31) - 16);
902                          code[loo - crypt64_sta + los[6 * i + j + 24]] = 8 * ((4 * i + j + 15) & 31) - 128;                          C(code, i, j, 24) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
903                    }                    }
904                  code[loo - crypt64_sta + los[6 * i + j + 12]] = 8 * ((4 * i + j +  7) & 31) - 128;                  C(code, i, j, 12) = sizeof(WS_T) * (((4 * i + j +  7) & 31) - 16);
905                  code[loo - crypt64_sta + los[6 * i + j + 36]] = 8 * ((4 * i + j + 23) & 31) - 128;                  C(code, i, j, 36) = sizeof(WS_T) * (((4 * i + j + 23) & 31) - 16);
906  #if DEBUG>=2  #if DEBUG>=2
907                    printf(" => %+3d:%+3d\n",                  //printf(" => %+3d:%+3d\n",
908                                   code[loo - crypt64_sta + los[6 * i + j     ]],                    printf(" => %08lX:%08lX\n",
909                                   code[loo - crypt64_sta + los[6 * i + j + 24]]);                                   C(code, i, j,  0),
910                                     C(code, i, j, 24));
911  #endif  #endif
912                  }                  }
913          }          }
# Line 912  reg_op(signed char *pc, Line 937  reg_op(signed char *pc,
937             unsigned d,             unsigned d,
938             unsigned s)             unsigned s)
939  {  {
940    #ifndef MMX
941      *pc++ = 0x66;
942    #endif
943    pc[0] = 0x0F;    pc[0] = 0x0F;
944    pc[1] = op;    pc[1] = op;
945    /* 11 ddd sss */    /* 11 ddd sss */
# Line 929  reg_mem(signed char *pc, Line 957  reg_mem(signed char *pc,
957                  unsigned s,                  unsigned s,
958                  long ofs)                  long ofs)
959  {  {
960    #ifndef MMX
961      *pc++ = 0x66;
962    #endif
963    pc[0] = 0x0F;    pc[0] = 0x0F;
964    pc[1] = op;    pc[1] = op;
965    if (-128 <= ofs && ofs <= 127)    if (-128 <= ofs && ofs <= 127)
# Line 1068  expr_make(signed char *iptr, Line 1099  expr_make(signed char *iptr,
1099                                                             oop,                                                             oop,
1100                                                             1,           /* MM1 */                                                             1,           /* MM1 */
1101                                                             5,           /* EBP */                                                             5,           /* EBP */
1102                                                             8 * (64 * ofs + j) + 8 * 32 - 8 * 16);                                                             sizeof(WS_T) * ((64 * ofs + j) + 32 - 16));
1103                                  oop = 0xEB;                                  oop = 0xEB;
1104                            }                            }
1105                    if (oop != 0xEB)                    if (oop != 0xEB)
# Line 1098  expr_make(signed char *iptr, Line 1129  expr_make(signed char *iptr,
1129                                                   op,                                                   op,
1130                                                   0,             /* MM0 */                                                   0,             /* MM0 */
1131                                                   5,             /* EBP */                                                   5,             /* EBP */
1132                                                   8 * (64 * ofs + c) + 8 * 32 - 8 * 16);                                                   sizeof(WS_T) * ((64 * ofs + c) + 32 - 16));
1133                    op = 0xDB;                    op = 0xDB;
1134                    ofs++;                    ofs++;
1135                  }                  }
# Line 1202  expr_parse(signed char *iptr, Line 1233  expr_parse(signed char *iptr,
1233                                   0x7F,                                   0x7F,
1234                                   7,                                   7,
1235                                   5,                                   5,
1236                                   8 * 31 - 8 * 16);                                   sizeof(WS_T) * (31 - 16));
1237  }  }
1238    
1239  static  static
# Line 1227  usec() Line 1258  usec()
1258   */   */
1259    
1260  /* 定数項 */  /* 定数項 */
1261  static struct SLICE const sk6[] =  #if N_STRIDE == 7
1262    static SLICE const sk6[N_STRIDE] =
1263    {
1264      {0xAAAAAAAAUL, 0xAAAAAAAAUL, 0xAAAAAAAAUL, 0xAAAAAAAAUL},
1265      {0xCCCCCCCCUL, 0xCCCCCCCCUL, 0xCCCCCCCCUL, 0xCCCCCCCCUL},
1266      {0xF0F0F0F0UL, 0xF0F0F0F0UL, 0xF0F0F0F0UL, 0xF0F0F0F0UL},
1267      {0xFF00FF00UL, 0xFF00FF00UL, 0xFF00FF00UL, 0xFF00FF00UL},
1268      {0xFFFF0000UL, 0xFFFF0000UL, 0xFFFF0000UL, 0xFFFF0000UL},
1269      {0x00000000UL, 0xFFFFFFFFUL, 0x00000000UL, 0xFFFFFFFFUL},
1270      {0x00000000UL, 0x00000000UL, 0xFFFFFFFFUL, 0xFFFFFFFFUL},
1271    };
1272    #elif N_STRIDE == 6
1273    static SLICE const sk6[N_STRIDE] =
1274  {  {
1275    {0xAAAAAAAAUL, 0xAAAAAAAAUL},    {0xAAAAAAAAUL, 0xAAAAAAAAUL},
1276    {0xCCCCCCCCUL, 0xCCCCCCCCUL},    {0xCCCCCCCCUL, 0xCCCCCCCCUL},
# Line 1236  static struct SLICE const sk6[] = Line 1279  static struct SLICE const sk6[] =
1279    {0xFFFF0000UL, 0xFFFF0000UL},    {0xFFFF0000UL, 0xFFFF0000UL},
1280    {0x00000000UL, 0xFFFFFFFFUL},    {0x00000000UL, 0xFFFFFFFFUL},
1281  };  };
1282    #endif
1283    
1284  #ifndef __GNUC__  #ifndef __GNUC__
1285  //typedef int (__msfastcall *CRYPT64_PP)(unsigned long const *k, unsigned long *lr);  //typedef int (__msfastcall *CRYPT64_PP)(unsigned long const *k, unsigned long *lr);
1286  typedef int (*CRYPT64_PP)(unsigned long const *k, unsigned long *lr);  typedef int (*CRYPT64_PP)(unsigned long const *k, unsigned long *lr);
1287  #endif  #endif
1288    
1289  int dmy;  struct KEY key64 __attribute__ ((aligned(16)));
1290    struct PARAM param64 __attribute__ ((aligned(16)));
 struct KEY key64;  
 struct PARAM param64;  
1291    
1292  int  int
1293  main(int argc, char *argv[])  main(int argc, char *argv[])
# Line 1278  main(int argc, char *argv[]) Line 1320  main(int argc, char *argv[])
1320  #endif  #endif
1321    
1322    /* t[16] は、内部演算で使用する、all 1 が入っている */    /* t[16] は、内部演算で使用する、all 1 が入っている */
1323    param64.t[16].a[0] = param64.t[16].a[1] = 0xFFFFFFFFUL;    for (i = 0; i < N_ALU; i++)
1324            param64.t[16].a[i] = -1;
1325    
1326    /* 固定キーのコピー */    /* 固定キーのコピー */
1327    for (i = 0; i < 6; i++)    for (i = 0; i < N_STRIDE; i++)
1328          {          {
1329            int o = tr_pc1[7][6 - i] - 1;            int o = tr_pc1[7][6 - i] - 1;
1330            if (o < 28)            if (o < 28)
# Line 1367  main(int argc, char *argv[]) Line 1410  main(int argc, char *argv[])
1410            int k, kk;            int k, kk;
1411    
1412            /* 鍵のセット */            /* 鍵のセット */
 #if 1  
1413            for (i = 0; i < 8; i++)            for (i = 0; i < 8; i++)
1414                  {                  {
1415                    key_set64(&key64, i, key[i], key[i] ^ okey[i], 0);                    key_set64(&key64, i, key[i], key[i] ^ okey[i], 0);
1416                    okey[i] = key[i];                    okey[i] = key[i];
1417                  }                  }
 #if 0  
                 for (j = 0; j < 7; j++)  
                   {  
                         int o = tr_pc1[i][6 - j] - 1;  
                         if (i == 7 && j < 6) continue;  
                         if (o < 28)  
                           {  
                                 assert(o >= 0);  
                                 key64.k[0][0][o].a[0]  
                                   = key64.k[0][0][o].a[1]  
                                   = key64.k[0][1][o].a[0]  
                                   = key64.k[0][1][o].a[1]  
                                   = -!!(key[i] & (1 << j));  
                           }  
                         else  
                           {  
                                 assert(o >= 28);  
                                 assert(o < 56);  
                                 key64.k[1][0][o - 28].a[0]  
                                   = key64.k[1][0][o - 28].a[1]  
                                   = key64.k[1][1][o - 28].a[0]  
                                   = key64.k[1][1][o - 28].a[1]  
                                   = -!!(key[i] & (1 << j));  
                           }  
                   }  
 #endif  
 #endif  
1418    
1419            /* まずは LR を初期化 */            /* まずは LR を初期化 */
1420                  //memset(param64.lr, 0, sizeof(param64.lr));                  //memset(param64.lr, 0, sizeof(param64.lr));
# Line 1422  main(int argc, char *argv[]) Line 1437  main(int argc, char *argv[])
1437                    fprintf(stderr, "cycle=%d\n", cnt);                    fprintf(stderr, "cycle=%d\n", cnt);
1438                  }                  }
1439            /* XXX 手抜きのため、ワークにはみ出ている2ビットを落とす */            /* XXX 手抜きのため、ワークにはみ出ている2ビットを落とす */
1440            memset(param64.t[0].a, 0, 2 * 8);            for (i = 0; i < N_ALU; i++)
1441                    param64.t[0].a[i] = param64.t[1].a[i] = 0;
1442    
1443            /* ヒットしたときの処理 */            /* ヒットしたときの処理 */
1444            for (kk = 0; kk < 2; kk++)            for (kk = 0; kk < N_ALU; kk++)
1445                  {                  {
1446                    unsigned t;                    ALU_T t;
1447  //continue;/*XXX*/  //continue;/*XXX*/
1448                    t = param64.t[31].a[kk];                    t = param64.t[31].a[kk];
1449  #if 1  #if 1
1450                    if (!t)                    if (!t)
1451                          continue;                          continue;
1452  #endif  #endif
1453                    for (k = 0; k < 32; k++)                    for (k = 0; k < ALU_BITS; k++)
1454                          {                          {
1455                            char hash[16];                            char hash[16];
1456                            unsigned char buf[32];                            unsigned char buf[32];
# Line 1500  main(int argc, char *argv[]) Line 1516  main(int argc, char *argv[])
1516                    int t = usec();                    int t = usec();
1517                    if (ts[N_TS - 1].c)                    if (ts[N_TS - 1].c)
1518                          {                          {
1519                            int a = 100 * 64 * (n_iter - ts[N_TS - 1].c) / (t - ts[N_TS - 1].t);                            int a = (100 << N_STRIDE) * (n_iter - ts[N_TS - 1].c) / (t - ts[N_TS - 1].t);
1520                            fprintf(stderr,                            fprintf(stderr,
1521                                            "%8d.%03d(ktrips/sec)\r",                                            "%8d.%03d(ktrips/sec)\r",
1522                                            a / 1000,                                            a / 1000,
Legend:
Removed from v.2  
changed lines
  Added in v.6
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help