home *** CD-ROM | disk | FTP | other *** search
/ Steganos Hacker Tools / SHT151.iso / programme / pw_bios / cmospwd4 / cmospwd.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-02-08  |  40.1 KB  |  1,609 lines
  1. /*
  2.  
  3.     File: cmospwd.c
  4.  
  5.     Copyright (C) 1998-2002 Christophe GRENIER <grenier@cgsecurity.org>
  6.     http://www.cgsecurity.org
  7.   
  8.     This software is free software; you can redistribute it and/or modify
  9.     it under the terms of the GNU General Public License as published by
  10.     the Free Software Foundation; either version 2 of the License, or
  11.     (at your option) any later version.
  12.   
  13.     This program is distributed in the hope that it will be useful,
  14.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.     GNU General Public License for more details.
  17.   
  18.     You should have received a copy of the GNU General Public License
  19.     along with this program; if not, write to the Free Software
  20.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22.     Thanks to Bluefish for BSD support
  23.  */
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <string.h>
  27. #ifdef __MSDOS__
  28. #include <dos.h>
  29. #include <ctype.h>
  30. #include <conio.h>
  31. #elif defined linux
  32. #include <unistd.h>
  33. #include <ctype.h>
  34. #include <errno.h>
  35. int  ioperm(unsigned  long,  unsigned  long, int);
  36. #elif defined WIN32
  37. #include <conio.h>
  38. #include <stdlib.h>
  39. #include <windows.h>
  40. #define outportb(PORT,VALUE) outp(PORT,VALUE)
  41. #define inportb(PORT) inp(PORT)
  42. //
  43. // Macro definition for defining IOCTL and FSCTL function control codes.  Note
  44. // that function codes 0-2047 are reserved for Microsoft Corporation, and
  45. // 2048-4095 are reserved for customers.
  46. //
  47.  
  48. #define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
  49.     ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
  50. )
  51. #define METHOD_BUFFERED                 0
  52. #define FILE_ANY_ACCESS                 0
  53.  
  54. #define DEVICE_NAME_STRING      L"gwiopm"
  55. #define IOPM_VERSION          110      // decimal
  56. #define IOPM_TEST0         0x0123
  57. #define IOPM_TEST1         0x1234
  58. #define IOPM_TEST2         0x2345
  59.  
  60. // Device type           -- in the "User Defined" range."
  61. #define IOPMD_TYPE 0xF100               // used several places
  62.  
  63. // The IOCTL function codes from 0x800 to 0xFFF are for non-Microsoft use.
  64. // LIOPM means "local I/O Permission Map" maintained by this driver.
  65. //-------------------------- 
  66. // Test functions
  67. #define IOCTL_IOPMD_READ_TEST        CTL_CODE(IOPMD_TYPE, 0x900, METHOD_BUFFERED, FILE_ANY_ACCESS ) // returns IOPM_TEST
  68. #define IOCTL_IOPMD_READ_VERSION     CTL_CODE(IOPMD_TYPE, 0x901, METHOD_BUFFERED, FILE_ANY_ACCESS ) // returns IOPM_VERSION
  69. // Manipulate local IOPM
  70. #define IOCTL_IOPMD_CLEAR_LIOPM      CTL_CODE(IOPMD_TYPE, 0x910, METHOD_BUFFERED, FILE_ANY_ACCESS ) // set map to block perm on all I/O addresses
  71. #define IOCTL_IOPMD_SET_LIOPM        CTL_CODE(IOPMD_TYPE, 0x911, METHOD_BUFFERED, FILE_ANY_ACCESS ) // set a byte (8 ports-worth) in LIOPM
  72. #define IOCTL_IOPMD_GET_LIOPMB       CTL_CODE(IOPMD_TYPE, 0x912, METHOD_BUFFERED, FILE_ANY_ACCESS ) // get a byte from LIOPM (diagnostic)
  73. #define IOCTL_IOPMD_GET_LIOPMA       CTL_CODE(IOPMD_TYPE, 0x913, METHOD_BUFFERED, FILE_ANY_ACCESS ) // get entire array of current LIOPM 
  74. // Interact with kernel
  75. #define IOCTL_IOPMD_ACTIVATE_KIOPM   CTL_CODE(IOPMD_TYPE, 0x920, METHOD_BUFFERED, FILE_ANY_ACCESS ) // copy LIOPM to be active map 
  76. #define IOCTL_IOPMD_DEACTIVATE_KIOPM CTL_CODE(IOPMD_TYPE, 0x921, METHOD_BUFFERED, FILE_ANY_ACCESS ) // tell NT to forget map 
  77. #define IOCTL_IOPMD_QUERY_KIOPM      CTL_CODE(IOPMD_TYPE, 0x922, METHOD_BUFFERED, FILE_ANY_ACCESS ) // get OS's IOPM into LIOPM? 
  78.  
  79. #define GWIOPM_PARAMCOUNT 3                            // for most functions
  80. #define GWIOPM_PARAMCOUNT_BYTES GWIOPM_PARAMCOUNT * 4  // for most functions
  81. #elif defined(bsd)
  82. #include <ctype.h>
  83. #include <stdlib.h>
  84. FILE *cmos_fd;
  85. #endif
  86.  
  87. typedef unsigned char      byte;    /* type of 8 bit unsigned quantity */
  88. typedef unsigned char        Bit8u;
  89. typedef unsigned short     Bit16u;  /* type of 16 bit unsigned quantity */
  90. typedef unsigned long      Bit32u;  /* type of 32 bit unsigned quantity */
  91. #define TAILLE_CMOS 0x80
  92. #define TAILLE_CMOS_MAX 1024
  93. #define TAILLE_BUFFER 2*0x200+TAILLE_CMOS_MAX
  94. #define MINLEN_CRC 6
  95. /* port i/o privileges & co. */
  96. #define IO_READ  1
  97. #define IO_WRITE 2
  98. #define IO_RDWR  (IO_READ | IO_WRITE)
  99. #define PORT_CMOS_0 0x70
  100. #define PORT_CMOS_1 0x71
  101. #define UNKNOWN_CAR '?'
  102. #define VAL_NON_STOP 256
  103. int get32(int position);
  104. void printchar(unsigned char car, int scancode);
  105. void aff_hexa(const unsigned char*buffer,const int lng);
  106. int build_table(const int position, const int lng, const int meth_parcourt, int *table);
  107. void table2val(const int *table, unsigned char *value, const int lng);
  108. void aff_result(const unsigned char *value, const int lng,const int val_stop,const int mode_aff);
  109. int generic_ami(unsigned char *value, const int lng, const int methode,const int val_stop);
  110. void generic_acer(unsigned char *value, const int lng,const int val_stop);
  111. void generic_dtk(unsigned char *value, const int lng,const unsigned char value_stop);
  112. void generic_compaq(unsigned char *value, const int lng,const unsigned char value_stop);
  113. void generic_unknown(unsigned char*value, const int lng,const int val_stop);
  114. void generic_phoenix_dec(unsigned char *value, const int lng,const unsigned char value_stop);
  115. void generic_phoenix_xor(unsigned char *value, const int lng,const unsigned char value_stop);
  116. void generic_phoenix_add(unsigned char *value, const int lng,const unsigned char value_stop);
  117. int check_filled(const unsigned char*value, const int lng, const unsigned char filled_value);
  118. void generic_basic(const int position, const int lng, const int meth_parcourt,const int algo,const int val_stop,const int mode_aff);
  119. int check_crcadd(int position, int size, int pos_crc);
  120. void generic_crc(int algo, int position);
  121. void award_backdoor(void);
  122.  
  123. byte scan2ascii(byte);
  124. unsigned char filtre(unsigned char);
  125. void dumpcmos(const int cmos_size, const int scancode);
  126. int ask_YN(const char*);
  127. byte parity_test(byte);
  128. Bit16u rol(Bit16u);
  129. Bit8u rcl8(Bit8u);
  130. Bit8u rcl8n(Bit8u, int);
  131. byte brute_awa(Bit16u, Bit16u, byte);
  132. byte brute_award(Bit16u);
  133. void set_permissions(void);
  134. void unset_permissions(void);
  135. Bit16u do_tosh(Bit16u, byte);
  136. byte brute_tosh(Bit16u, Bit16u, byte);
  137. byte brute_toshiba(Bit16u);
  138. #define m_acer          "\nAcer/IBM                     "
  139. #define m_ami_old       "\nAMI BIOS                     "
  140. #define m_ami_winbios   "\nAMI WinBIOS (12/15/93)       "
  141. #define m_ami_winbios2  "\nAMI WinBIOS 2.5              "
  142. #define m_award         "\nAward 4.5x/6.0               "
  143. #define m_award_medallion "\nAward Medallion 6.0          "
  144. #define m_compaq        "\nCompaq (1992)                "
  145. #define m_compaq2       "\nCompaq                       "
  146. #define m_compaq3       "\nCompaq DeskPro               "
  147. #define m_dtk            "\nDTK                          "
  148. #define m_phoenixa08    "\nPhoenix A08, 1993            "
  149. #define m_ibm           "\nIBM (PS/2, Activa ...)       "
  150. #define m_ibm_thinkpad  "\nIBM Thinkpad boot pwd        "
  151. #define m_ibm_300       "\nIBM 300 GL                   "
  152. #define m_ibm_thinkpad2 "\nIBM Thinkpad 765 EEPROM      "
  153. #define m_packardbell   "\nPackard Bell Supervisor/User "
  154. #define m_phoenix       "\nPhoenix 1.00.09.AC0 (1994)   "
  155. #define m_phoenix2      "\nPhoenix 1.04                 "
  156. #define m_phoenix3      "\nPhoenix 1.10 A03             "
  157. #define m_phoenix4      "\nPhoenix 4 release 6 (User)   "
  158. #define m_phoenix5    "\nPhoenix 4.0 release 6.0      "
  159. #define m_phoenix6    "\nPhoenix a486 1.03            "
  160. #define m_phoenix405    "\nPhoenix 4.05 rev 1.02.943    "
  161. #define m_phoenix406    "\nPhoenix 4.06 rev 1.13.1107   "
  162. #define m_gateway_ph    "\nGateway Solo Phoenix 4.0 r6  "
  163. #define m_toshiba       "\nToshiba                      "
  164. #define m_zenith_ami    "\nZenith AMI Supervisor/User   "
  165.  
  166. void acer(void);
  167. void ami_old(void);
  168. void ami_winbios(void);
  169. void ami_winbios2(void);
  170. void award(void);
  171. void award_medallion(void);
  172. void compaq(void);
  173. void compaq2(void);
  174. void compaq3(void);
  175. void dtk(void);
  176. void phoenixa08(void);
  177. void ibm(void);
  178. void ibm_thinkpad(void);
  179. void ibm_thinkpad2(void);
  180. void ibm_300(void);
  181. void packardbell(void);
  182. void phoenix(void);
  183. void phoenix2(void);
  184. void phoenix3(void);
  185. void phoenix4(void);
  186. void phoenix5(void);
  187. void phoenix6(void);
  188. void phoenix405(void);
  189. void phoenix406(void);
  190. void gateway_ph(void);
  191. void toshiba(void);
  192. void zenith_ami(void);
  193. void (*tbl_func[])(void)={acer,
  194.     ami_old,ami_winbios,ami_winbios2,
  195.     award, award_medallion,
  196.     compaq,compaq3,compaq2,
  197.     dtk,
  198.     phoenixa08,
  199.     ibm,ibm_thinkpad,ibm_thinkpad2,ibm_300,
  200.     packardbell,
  201.     phoenix,phoenix2,phoenix3,phoenix4,phoenix5,phoenix6,phoenix405,phoenix406,gateway_ph,
  202.     toshiba,
  203.     zenith_ami };
  204. #define nbr_func sizeof(tbl_func)/sizeof(*tbl_func)
  205. int kill_cmos(const int cmos_size);
  206. int load_cmos(const int cmos_size);
  207. int restore_cmos(const int cmos_size,const int choix);
  208. int load_backup(const char*);
  209. int save_backup(const int cmos_size, const char* name);
  210. char get_table_pb(unsigned char);
  211. void generic_packard(unsigned char *value, const int lng,const unsigned char value_stop);
  212.  
  213. typedef struct s_cmos_f t_cmos_f;
  214. typedef struct s_cmos_l t_cmos_l;
  215. typedef struct s_cmos t_cmos;
  216.  
  217. struct s_cmos_f
  218. {
  219.   int scancode;
  220.   int position;
  221.   int size;
  222.   int order;
  223. };
  224.  
  225. struct s_cmos_l
  226. {
  227.   int type;
  228.   char* info;
  229.   t_cmos_l *next;
  230. };
  231.  
  232. struct s_cmos
  233. {
  234.   char *name;
  235.   t_cmos_l *first;
  236. };
  237.  
  238.  
  239. #if defined(linux)||defined(bsd)
  240. static __inline__ void outportb(Bit32u port,byte value)
  241. {
  242.   __asm__ volatile ("outb %0,%1"
  243.             ::"a" ((char) value), "d"((Bit16u) port));
  244. }
  245.  
  246. static __inline__ byte inportb(Bit32u port)
  247. {
  248.   byte _v;
  249.   __asm__ volatile ("inb %1,%0"
  250.              :"=a" (_v):"d"((Bit16u) port));
  251.   return _v;
  252. }
  253. #endif
  254.  
  255. enum {KEYB_US,KEYB_FR, KEYB_DE};
  256. int keyb=KEYB_US;
  257. byte cmos[TAILLE_CMOS_MAX];
  258.  
  259. int get32(int position)
  260. {
  261.   return ((cmos[position+1] <<8) | cmos[position]);
  262. }
  263.  
  264. /* CONVERTION ET FILTRAGE */
  265. byte scan2ascii(byte car)
  266. {
  267.   static const byte tbl_fr[255]=
  268.   { ' ',' ','1','2','3','4','5','6',
  269.     '7','8','9','0',')','=',' ',' ',
  270.     'A','Z','E','R','T','Y','U','I',     /* 10 */
  271.     'O','P',' ','$',' ',' ','Q','S',     /* 18 */
  272.     'D','F','G','H','J','K','L','M',     /* 20 */
  273.     '%','²',' ','*','W','X','C','V',
  274.     'B','N',',',';',':','/',' ','*',     /* 30 */
  275.     ' ',' ',' ','f','f','f','f','f',     /* F1 a F10 */
  276.     'f','f','f','f','f',' ',' ','7',     /* 40 */
  277.     '8','9','-','4','5','6','+','1',
  278.     '2','3','0','.',' ',' ','>',' '};    /* 50 */
  279.  
  280.     static const byte tbl_de[255]=
  281.     { ' ',' ','1','2','3','4','5','6',
  282.       '7','8','9','0','-','=',' ',' ',
  283.       'Q','W','E','R','T','Z','U','I',     /* 10 */
  284.       'O','P',' ','$',' ',' ','A','S',     /* 18 */
  285.       'D','F','G','H','J','K','L',';',     /* 20 */
  286.       '∙','`',' ','*','Y','X','C','V',
  287.       'B','N','M',',','.','/','"','*',     /* 30 */
  288.       ' ',' ',' ','f','f','f','f','f',     /* F1 a F10 */
  289.       'f','f','f','f','f',' ',' ','7',     /* 40 */
  290.       '8','9','-','4','5','6','+','1',
  291.       '2','3','0','.',' ',' ','>',' '};    /* 50 */
  292.  
  293.     static const byte tbl_us[255]=
  294.     { ' ',' ','1','2','3','4','5','6',
  295.       '7','8','9','0','-','=',' ',' ',
  296.       'Q','W','E','R','T','Y','U','I',     /* 10 */
  297.       'O','P',' ','$',' ',' ','A','S',     /* 18 */
  298.       'D','F','G','H','J','K','L',';',     /* 20 */
  299.       '∙','`',' ','*','Z','X','C','V',
  300.       'B','N','M',',','.','/','"','*',     /* 30 */
  301.       ' ',' ',' ','f','f','f','f','f',     /* F1 a F10 */
  302.       'f','f','f','f','f',' ',' ','7',     /* 40 */
  303.       '8','9','-','4','5','6','+','1',
  304.       '2','3','0','.',' ',' ','>',' '};    /* 50 */
  305. /* start */
  306.   if (car<0x58)
  307.   {
  308.     switch(keyb)
  309.     {
  310.       case KEYB_FR:
  311.     return tbl_fr[car];
  312.       case KEYB_DE:
  313.     return tbl_de[car];
  314.       case KEYB_US:
  315.       default:
  316.     return tbl_us[car];
  317.     }
  318.   }
  319.   return ' ';
  320. }
  321.  
  322. unsigned char filtre(unsigned char lettre)
  323. {
  324.   if ((lettre>=32) && (lettre <=125))
  325.     return lettre;
  326.   else
  327.     switch(lettre)
  328.     {
  329.       case(131):
  330.       case(132):
  331.       case(133):
  332.       case(134):
  333.       case(160):
  334.     return 'a';
  335.       case(130):
  336.       case(136):
  337.       case(137):
  338.       case(138):
  339.     return 'e';
  340.       case(139):
  341.       case(140):
  342.       case(141):
  343.       case(161):
  344.     return 'i';
  345.       case(164):
  346.     return 'n';
  347.       case(147):
  348.       case(148):
  349.       case(149):
  350.       case(162):
  351.     return 'o';
  352.       case(150):
  353.       case(151):
  354.       case(163):
  355.     return 'u';
  356.       case(152):
  357.     return 'y';
  358.       case(142):
  359.       case(143):
  360.     return 'A';
  361.       case(144):
  362.     return 'E';
  363.       case(165):
  364.     return 'N';
  365.       case(153):
  366.     return 'O';
  367.       case(154):
  368.     return 'U';
  369.       default:
  370.     return ' ';
  371.     }
  372. }
  373.  
  374. char get_table_pb(unsigned char val)
  375. {
  376.   switch(val)
  377.   {
  378.     case 0xE7:
  379.     case 0x3F:
  380.       return 'B';
  381.     case 0xA3:
  382.       return 'C';
  383.     case 0xFB:
  384.       return 'D';
  385.     case 0xBD:
  386.       return 'E';
  387.     case 0xF6:
  388.       return 'F';
  389.     case 0x77:
  390.       return 'G';
  391.     case 0xB9:
  392.       return 'H';
  393.     case 0xCF:
  394.       return 'O';
  395.     case 0xD7:
  396.       return 'T';
  397.   }
  398.   return UNKNOWN_CAR;
  399. }
  400.  
  401. /* Affichage de caractere */
  402. void printchar(unsigned char car, int scancode)
  403. {
  404.   printf("%c", filtre(scancode?scan2ascii(car):car));
  405. }
  406.  
  407. /* Affichage de la cmos */
  408.  
  409. void dumpcmos(const int cmos_size, const int scancode)
  410. {
  411.   int i,j;
  412.   for (i=0;i<cmos_size;i+=0x10)
  413.   {
  414.     printf("\n%02X: ", i);
  415.     for(j=0;j<0x10;j++)
  416.       printf("%02X ", cmos[i+j]);
  417.     printf(" |");
  418.     for(j=0;j<0x10;j++)
  419.       printchar(cmos[i+j],scancode);
  420.     printf("|");
  421.   }
  422.   printf("\n");
  423. }
  424.  
  425. void aff_hexa(const unsigned char*buffer,const int lng)
  426. {
  427.   int i;
  428.   for(i=0;i<lng;i++)
  429.     printf("%02X ",buffer[i]);
  430. }
  431.  
  432. /* test et manipulation binaire */
  433. byte parity_test(byte val)
  434. {
  435.   int res=0;
  436.   int i;
  437.   for(i=0;i<8;i++)
  438.   {
  439.     if(val&1)
  440.       res^=1;
  441.     val>>=1;
  442.   }
  443.   return res;
  444. }
  445.  
  446. Bit8u rcl8(Bit8u num)
  447. {
  448.   return (num<<1)|(num >> 7);
  449. }
  450.  
  451. Bit8u rcl8n(Bit8u num,int n)
  452. {
  453.   int i;
  454.   Bit8u res=num;
  455.   for(i=0;i<n;i++)
  456.     res=rcl8(res);
  457.   return res;
  458. }
  459.  
  460. Bit16u rol(Bit16u n)
  461. {
  462.   return (n<<2)| ((n & 0xC000) >> 14);
  463. }
  464. /* Fonctions generiques */
  465. /*
  466.  *    pos_ini, size, meth_parcourt(COPIE, COPIE2)
  467.  * => table
  468.  * => table_de_valeur
  469.  * => pre-verif
  470.  * => decryptage
  471.  * => post-verif
  472.  * => affichage direct ou apres conversion scan2ascii
  473.  *
  474.  * methode_CRC
  475.  *    pos_ini
  476.  * => valeur
  477.  * => brute force
  478.  * */
  479.  
  480. enum { METH_PARC_NORMAL, METH_PARC_SWAP };
  481. enum { ALGO_AMI_F0, ALGO_AMI, ALGO_AMI_80, ALGO_UNKNOW, ALGO_AWARD, ALGO_TOSHIBA, ALGO_ACER, ALGO_PACKARD,ALGO_NONE,ALGO_PHOENIX_DEC,ALGO_PHOENIX_XOR,ALGO_PHOENIX_ADD,ALGO_DTK,ALGO_COMPAQ};
  482. enum { AFF_SCAN,AFF_ASCII};
  483.  
  484. int build_table(const int position, const int lng, const int meth_parcourt, int *table)
  485. {
  486.   int i;
  487.   switch(meth_parcourt)
  488.   {
  489.     case METH_PARC_NORMAL:
  490.       for(i=0;i<lng;i++)
  491.     table[i]=position+i;
  492.       return 0;
  493.     case METH_PARC_SWAP:
  494.       for(i=0;i<lng;i+=2)
  495.       {
  496.     table[i]=position+i+1;
  497.     if(i+1<lng)
  498.       table[i+1]=position+i;
  499.       }
  500.       return 0;
  501.   }
  502.   return 1;
  503. }
  504.  
  505. void table2val(const int *table, unsigned char *value, const int lng)
  506. {
  507.   int i;
  508.   for(i=0;i<lng;i++)
  509.     if(table[i])
  510.       value[i]=cmos[table[i]];
  511.     else
  512.       value[i]=UNKNOWN_CAR;
  513. }
  514.  
  515. void aff_result(const unsigned char *value, const int lng,const int val_stop,const int mode_aff)
  516. {
  517.   int i;
  518.   putchar('[');
  519.   for(i=0;(i<lng) && (value[i]!=val_stop);i++)
  520.   {
  521.     if(value[i]==UNKNOWN_CAR)
  522.       putchar('?');
  523.     else
  524.       switch(mode_aff)
  525.       {
  526.     case AFF_ASCII:
  527.       putchar(filtre(value[i]));
  528.       break;
  529.     case AFF_SCAN:
  530.       putchar(filtre(scan2ascii(value[i])));
  531.       break;
  532.     default:
  533.       printf("Bad display method");
  534.       }
  535.   }
  536.   putchar(']');
  537. }
  538.  
  539. int generic_ami(unsigned char *value, const int lng, const int methode,const int val_stop)
  540. {
  541.   int pos;
  542.   unsigned char ah,al;
  543.   switch(methode)
  544.   {
  545.     case ALGO_AMI_F0:     al=value[0] & 0xF0; break;
  546.     case ALGO_AMI:     al=value[0]; break;
  547.     case ALGO_AMI_80:     al=0x80; break;
  548.     default:        printf("Bad AMI ALGO"); return 1;
  549.   }
  550.   for(pos=1;pos<lng;pos++)
  551.   {
  552.     int i;
  553.     ah=al;
  554.     al=value[pos];
  555.     if (al==val_stop) break;
  556.     for (i=0;i<=255;i++)
  557.     {
  558.       if (al==ah) break;
  559.       if (parity_test(0xE1&al)) al=(al<<1)|1; else al<<=1;
  560.     }
  561.     al=value[pos];
  562.     if(i>255)
  563.       value[pos-1]=UNKNOWN_CAR;
  564.     else
  565.       value[pos-1]=i;
  566.     value[pos]=val_stop;
  567.   }
  568.   return 0;
  569. }
  570.  
  571. void generic_acer(unsigned char *value, const int lng,const int val_stop)
  572. {
  573.   int i;
  574.   for(i=0;(i<lng)&&(value[i]!=val_stop);i++)
  575.     value[i]=value[i]>>1;    /* ibm_1 */
  576.   /* shr al,1        D0 E8
  577.    * cmp al,[bx+si]    3A 00
  578.    */
  579. }
  580.  
  581. void generic_unknown(unsigned char*value, const int lng,const int val_stop)
  582. {
  583.   int i;
  584.   for(i=0;(i<lng)&&(value[i]!=val_stop);i++)
  585.     value[i]=UNKNOWN_CAR;
  586. }
  587.  
  588. int check_filled(const unsigned char*value, const int lng, const unsigned char filled_value)
  589. {
  590.   int i;
  591.   int etat=0;
  592.   for(i=0;i<lng;i++)
  593.   {
  594.     switch(etat)
  595.     {
  596.       case 0:
  597.     if(value[i]==filled_value)
  598.       etat++;
  599.     break;
  600.       case 1:
  601.     if(value[i]!=filled_value)
  602.       return 1;
  603.     }
  604.   }
  605.   return 0;
  606. }
  607.  
  608. void generic_table(const int *table, const int lng, const int algo,const int val_stop,const int mode_aff);
  609.  
  610. void generic_basic(const int position, const int lng, const int meth_parcourt,const int algo,const int val_stop,const int mode_aff)
  611. {
  612. #ifdef __MSDOS__
  613.   int table[10];
  614. #else
  615.   int table[lng];
  616. #endif
  617.   build_table(position,lng,meth_parcourt,table);
  618.   generic_table(table,lng,algo,val_stop,mode_aff);
  619. }
  620.  
  621. void generic_table(const int *table, const int lng, const int algo,const int val_stop,const int mode_aff)
  622. {
  623. #ifdef __MSDOS__
  624.   unsigned char value[10];
  625. #else
  626.   unsigned char value[lng];
  627. #endif
  628.   table2val(table,value,lng);
  629.   switch(algo)
  630.   {
  631.     case ALGO_AMI_F0:
  632.     case ALGO_AMI:
  633.     case ALGO_AMI_80:
  634.       generic_ami(value,lng,algo,val_stop);
  635.       break;
  636.     case ALGO_UNKNOW:
  637.       generic_unknown(value,lng,val_stop);
  638.       break;
  639.     case ALGO_ACER:
  640.       generic_acer(value,lng,val_stop);
  641.       break;
  642.     case ALGO_PACKARD:
  643.       check_filled(value,lng,val_stop);
  644.       generic_packard(value,lng,val_stop);
  645.       break;
  646.     case ALGO_NONE:
  647.       break;
  648.     case ALGO_PHOENIX_DEC:
  649.       generic_phoenix_dec(value,lng,val_stop);
  650.       break;
  651.     case ALGO_PHOENIX_XOR:
  652.       generic_phoenix_xor(value,lng,val_stop);
  653.       break;
  654.     case ALGO_PHOENIX_ADD:
  655.       generic_phoenix_add(value,lng,val_stop);
  656.       break;
  657.     case ALGO_DTK:
  658.       generic_dtk(value,lng,val_stop);
  659.       break;
  660.     case ALGO_COMPAQ:
  661.       generic_compaq(value,lng,val_stop);
  662.       break;
  663.     default:
  664.       printf("BAD ALGO ");
  665.       return;
  666.   }
  667.   aff_result(value,lng,val_stop,mode_aff);
  668. }
  669. /* ================================================================= */
  670. int check_crcadd(int position, int size, int pos_crc)
  671. {
  672.   int i;
  673.   int crc=0;
  674.   for(i=position;i<position+size;i++)
  675.     crc+=cmos[i];
  676.   return ((crc & 0xFF) == cmos[pos_crc]);
  677. }
  678.  
  679. void generic_packard(unsigned char *value, const int lng,const unsigned char value_stop)
  680. {
  681.   int i;
  682.   for(i=1;(i<lng)&&(value[i]!=value_stop);i++) /* Ecrase le "CRC ?" */
  683.   {
  684.     value[i-1]=get_table_pb(value[i]);
  685.     value[i]=value_stop;
  686.   }
  687. }
  688. /* ==================================================== */
  689.  
  690. void generic_crc(int algo, int position)
  691. {
  692.   switch(algo)
  693.   {
  694.     case ALGO_AWARD:
  695.       brute_award(get32(position));
  696.       break;
  697.     case ALGO_TOSHIBA:
  698.       brute_toshiba(get32(position));
  699.       break;
  700.   }
  701. }
  702.  
  703. /* Brute force Award */
  704. int awa_pos;
  705. char awa_res[9];
  706.  
  707. byte brute_awa(Bit16u but, Bit16u somme, byte lng)
  708. {
  709.   byte p;
  710.   static byte const tbl_car[]={'0','1','2','3','4','5','6'};
  711.  
  712.   if (lng==0)
  713.     return (but==somme);
  714.   else
  715.       for (p=0;p<4;p++)
  716.       if (brute_awa(but, rol(somme) + tbl_car[p], lng-1))
  717.         {
  718.           awa_res[awa_pos++]=tbl_car[p];
  719.           return 1;
  720.         }
  721.   return 0;
  722. }
  723.  
  724. byte brute_award(Bit16u but)
  725. {
  726.   int i;
  727.   byte res;
  728.   awa_pos=0;
  729.   for(i=0;i<9;i++)
  730.     awa_res[i]='\0';
  731.   for (i=1;i<=8;i++)
  732.   {
  733.     res=brute_awa(but, 0,i);
  734.    if (res) break;
  735.   }
  736. #ifndef TEST
  737.   printf("[");
  738.   for (i=awa_pos-1;i>=0;i--) printf("%c", awa_res[i]);
  739.   printf("]");
  740. #endif
  741.   return res;
  742. }
  743.  
  744. /* Brute force Toshiba */
  745. Bit16u do_tosh(Bit16u valcrc, byte car)
  746. {
  747.     register byte ah,al,dh,dl;
  748.     al=(byte)valcrc;
  749.     ah=valcrc>>8;
  750.     ah^=car;    /* xor ah,[bx] */
  751.     dl=ah;    /* mov dl,ah */
  752.     dl<<=4;    /* shl dl,4     C0 E2 04 */
  753.     ah^=dl;     /* xor ah,dl     32 E2 */
  754.     dl=ah;      /* mov dl,ah     8A D4 */
  755.     dl>>=5;    /* shl dl,5 */
  756.     dl^=ah;    /* xor dl,ah */
  757.     dh=ah;
  758.     ah<<=3;
  759.     ah^=al;
  760.     dh>>=4;
  761.     ah^=dh;
  762.     al=dl;
  763.     return (ah<<8)|al;
  764. }
  765.  
  766. int tosh_pos;
  767. char tosh_res[11];
  768.  
  769. byte brute_tosh(Bit16u but, Bit16u valcrc, byte lng)
  770. {
  771.   unsigned int p;
  772.   static byte const tbl_car[]={0x10,0x11,0x12,0x13,0x14,0x20};
  773.  
  774.   if (lng==0)
  775.   {
  776.     if(valcrc==0)
  777.       valcrc++;
  778.     return (but==valcrc);
  779.   }
  780.   else
  781.   {
  782.     for (p=0;p<sizeof(tbl_car);p++)
  783.       if (brute_tosh(but, do_tosh(valcrc,tbl_car[p]), lng-1))
  784.       {
  785.     tosh_res[tosh_pos++]=tbl_car[p];
  786.     return 1;
  787.       }
  788.   }
  789.   return 0;
  790. }
  791.  
  792. byte brute_toshiba(Bit16u but)
  793. {
  794.   int i;
  795.   byte res;
  796.   tosh_pos=0;
  797.   if(but==0)
  798.   {
  799.     printf("[KEY floppy]");
  800.     return 1;
  801.   }
  802.   for(i=0;i<10;i++)
  803.     tosh_res[i]='\0';
  804.   for (i=1;i<=10;i++)
  805.   {
  806.     res=brute_tosh(but, 0,i);
  807.    if (res) break;
  808.   }
  809.   if(res)
  810.   {
  811.     putchar('[');
  812.     for (i=tosh_pos-1;i>=0;i--)
  813.       putchar(scan2ascii(tosh_res[i]));
  814.     putchar(']');
  815.   }
  816.   else
  817.     printf("\nEchec");
  818.   return res;
  819. }
  820.  
  821. void acer()                /* ACER */
  822. {
  823.   printf(m_acer);
  824.   generic_basic(0x27, 7, METH_PARC_NORMAL,ALGO_ACER,0,AFF_SCAN);
  825. }
  826.  
  827. void ami_old()                /* AMI */
  828. {
  829.   printf(m_ami_old);
  830.   generic_basic(0x37, 1+6, METH_PARC_NORMAL,ALGO_AMI_F0,0,AFF_ASCII);
  831. }
  832.  
  833. void ami_winbios()
  834. {
  835.   printf(m_ami_winbios);
  836.   generic_basic(0x37, 1+6, METH_PARC_NORMAL,ALGO_AMI,0,AFF_SCAN);
  837. }
  838.  
  839. void ami_winbios2()
  840. {
  841.   printf(m_ami_winbios2);
  842.   generic_basic(0x37, 1+6, METH_PARC_NORMAL,ALGO_AMI_80,0,AFF_SCAN);
  843.   generic_basic(0x4B, 1+6, METH_PARC_NORMAL,ALGO_AMI_80,0,AFF_SCAN);
  844. }
  845.  
  846. /* AMI          @art.fr         CRC+Crypted adm pwd at 38-3F, filled with 00
  847.  *                              user pwd at 0x40-47     */
  848. void zenith_ami()
  849. {
  850.   printf(m_zenith_ami);
  851.   generic_basic(0x38+1, 7, METH_PARC_NORMAL,ALGO_UNKNOW,0,AFF_ASCII);
  852.   putchar(' ');
  853.   generic_basic(0x40+1, 7, METH_PARC_NORMAL,ALGO_UNKNOW,0,AFF_ASCII);
  854. }
  855.  
  856.  
  857.  
  858.                 /* AWARD */
  859. void award()
  860. {
  861.   printf(m_award);
  862.   generic_crc(ALGO_AWARD,0x1C);
  863.   generic_crc(ALGO_AWARD,0x60);
  864.   generic_crc(ALGO_AWARD,0x4D);
  865.   printf(m_award);
  866.   generic_crc(ALGO_AWARD,0x63); /* putamadre7@hotmail.com */
  867.   generic_crc(ALGO_AWARD,0x64); /* jedi@ukgateway.net */
  868.   generic_crc(ALGO_AWARD,0x5D); /* Setup YOGESH M <my@myw.ltindia.com> */
  869. }
  870.  
  871. void award_medallion()
  872. {
  873. /* Pencho Penchev <ppencho@hotmail.com>
  874.    Hewllett Packard Brio system
  875. */
  876.   printf(m_award_medallion);
  877.   generic_crc(ALGO_AWARD,0x68);    /* supervisor */
  878.   generic_crc(ALGO_AWARD,0x6A); /* user */
  879. }
  880.  
  881.                 /* COMPAQ */
  882. void compaq()
  883. {
  884.   printf(m_compaq);
  885.   generic_basic(0x38, 8, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  886. }
  887.  
  888. void compaq2()
  889. {
  890.   printf(m_compaq2);
  891.   generic_basic(0x51, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN); /* setup */
  892.   generic_basic(0x38, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  893. }
  894.  
  895.  
  896. void compaq3()
  897. {
  898.   printf(m_compaq3);
  899.   /* - Luka "The /\/\ighty \/\/izzy" <cd.roma@flashnet.it>
  900.    *   Compaq 5200, August 1998
  901.    */
  902.   generic_basic(0x37, 8, METH_PARC_NORMAL,ALGO_COMPAQ,0,AFF_SCAN);
  903.    /* - Quattrocchi Stefano <S.Quattrocchi@tecnimont.it>
  904.     *   Compaq DeskPro EP Serie 6350/6.4 EA2, May 2001
  905.     */
  906.   generic_basic(0x77, 8, METH_PARC_NORMAL,ALGO_COMPAQ,0,AFF_SCAN);
  907. }
  908.  
  909.  
  910.                 /* IBM */
  911. void ibm()
  912. {
  913.   printf(m_ibm);
  914.   generic_basic(0x48, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  915.   generic_basic(0x38, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  916. }
  917.  
  918. void ibm_thinkpad()
  919. {
  920.   printf(m_ibm_thinkpad);
  921.   generic_basic(0x38, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);    /* pwd boot */
  922. }
  923.  
  924. void ibm_thinkpad2()
  925. {
  926.   printf(m_ibm_thinkpad2);
  927.   generic_basic(0x38, 7, METH_PARC_SWAP,ALGO_NONE,0,AFF_SCAN);
  928.   generic_basic(0x40, 7, METH_PARC_SWAP,ALGO_NONE,0,AFF_SCAN);
  929. }
  930.  
  931. void ibm_300()
  932. {
  933.   printf(m_ibm_300);
  934.   generic_basic(0x48, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  935. }
  936.  
  937. void packardbell()                /* PACKARD BELL */
  938. {
  939.   printf(m_packardbell);
  940.   generic_basic(0x38, 1+7, METH_PARC_NORMAL,ALGO_PACKARD,0xFF,AFF_ASCII);
  941.   putchar(' ');
  942.   generic_basic(0x40, 1+7, METH_PARC_NORMAL,ALGO_PACKARD,0xFF,AFF_ASCII);
  943. }
  944.  
  945. /* ICI */
  946. void phoenix()                /* PHOENIX */
  947. {
  948.   static const int tbl_phoenix[8]={0x39,0x3C,0x3B,0x3F,0x38,0x3E,0x3D,0x3A};
  949.   byte res[8];
  950.   byte crc=0;
  951.   byte i;
  952.   printf(m_phoenix);
  953.   for (i=0;i<7;i++)
  954.   {
  955.     res[i]=cmos[tbl_phoenix[i]];
  956.     if (res[i]==0) break;
  957.     res[i]=(res[i] ^ 0xF0) + i;
  958.     crc+=res[i];
  959.   }
  960.   if (crc==cmos[tbl_phoenix[7]])
  961.     printf("[%s]", res);
  962.   else
  963.     printf("CRC pwd err");
  964.   generic_table(tbl_phoenix, 7, ALGO_PHOENIX_XOR,0,AFF_ASCII);
  965. }
  966.  
  967. void phoenix2()
  968. {
  969.   printf(m_phoenix2);
  970.   generic_basic(0x50, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN); /* setup */
  971.   generic_basic(0x48, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  972. }
  973.  
  974.  
  975.  
  976. void phoenix3()
  977. { /* Phoenix Bios V1.10 A03 / Dell GXi */
  978.   printf(m_phoenix3);
  979.   if(!check_crcadd(0x1D,7,0x1D+7) || !check_crcadd(0x38,7,0x38+7))
  980.   {
  981.     printf("CRC pwd err");
  982.     return;
  983.   }
  984.   generic_basic(0x1D, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN); /* setup */
  985.   generic_basic(0x38, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  986. }
  987.  
  988. void phoenix4()
  989. {
  990.   printf(m_phoenix4);
  991.   generic_basic(0x35, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN); /* user */
  992. }
  993.  
  994. void generic_phoenix_dec(unsigned char *value, const int lng,const unsigned char value_stop)
  995. {
  996.   int i;
  997.   for(i=0;(i<lng)&&(value[i]!=value_stop);i++)
  998.     value[i]=rcl8n(value[i],i+1);
  999. }
  1000.  
  1001. void generic_phoenix_xor(unsigned char *value, const int lng,const unsigned char value_stop)
  1002. {
  1003.   int i;
  1004.   for(i=0;(i<lng)&&(value[i]!=value_stop);i++)
  1005.     value[i]=(value[i] ^ 0xF0) + i;
  1006. }
  1007.  
  1008. void generic_phoenix_add(unsigned char *value, const int lng,const unsigned char value_stop)
  1009. {
  1010.   int i;
  1011.   for(i=0;(i<lng)&&(value[i]!=value_stop);i++)
  1012.     value[i]+=0x20;
  1013. }
  1014.  
  1015.  
  1016. void phoenix5()
  1017. {
  1018.   printf(m_phoenix5);
  1019.   generic_basic(0x35, 7, METH_PARC_NORMAL,ALGO_PHOENIX_DEC,0,AFF_SCAN);
  1020. }
  1021.  
  1022. void phoenix6()
  1023. {
  1024.   printf(m_phoenix6);
  1025.   if(((cmos[0x60]==0)||(cmos[0x60]==1))&&(cmos[0x61]<=7))
  1026.     generic_basic(0x62, cmos[0x61], METH_PARC_NORMAL,ALGO_PHOENIX_ADD,0xFF,AFF_ASCII);
  1027.   else
  1028.     printf("err");
  1029.   /* CRC 32 en 7E
  1030.    * 3B-3D => 6A-6C
  1031.    * 40 => 6F
  1032.    * */
  1033. }
  1034.  
  1035. void phoenix405()
  1036. {
  1037.   static const int tbl[8]={0x45,0x52,0x4b,0x4a,0x50,0x4F,0x4D,0x48};
  1038.   static const int tbl2[8]={0x4c,0x51,0x49,0x54,0x53,0x47,0x46,0x4E};
  1039.   printf(m_phoenix405);
  1040.   generic_table(tbl, 8, ALGO_NONE,0,AFF_SCAN);
  1041.   generic_table(tbl2, 8, ALGO_NONE,0,AFF_SCAN);
  1042. }
  1043.  
  1044. void phoenix406()
  1045. {
  1046.   printf(m_phoenix406);
  1047.   generic_basic(0x45, 8, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  1048. }
  1049.  
  1050. void dtk()
  1051. {
  1052.   printf(m_dtk);
  1053.   generic_basic(0x38,4,METH_PARC_NORMAL,ALGO_DTK,0,AFF_ASCII);
  1054.   generic_basic(0x3B,6,METH_PARC_NORMAL,ALGO_DTK,0,AFF_ASCII);
  1055. }
  1056.  
  1057. void generic_dtk(unsigned char *value, const int lng,const unsigned char value_stop)
  1058. {
  1059.   int i;
  1060. #ifdef __MSDOS__
  1061.   unsigned char value2[10];
  1062. #else
  1063.   unsigned char value2[lng];
  1064. #endif
  1065.   for(i=0;i<lng;i++)
  1066.   {
  1067.     int b;
  1068.     switch(i%4)
  1069.     {
  1070.       case 0: b=value[(i/4)*3] >> 2; break;
  1071.       case 1: b=(value[(i/4)*3] << 4) + (value[(i/4)*3+1]>>4); break;
  1072.       case 2: b=((value[(i/4)*3+1] << 2) & 0x3C) + (value[(i/4)*3+2] >> 6); break;
  1073.       case 3: b=value[(i/4)*3+2]; break;
  1074.     }
  1075.     b=b&0x3F;
  1076.     if(b==0)
  1077.       break;
  1078.     if(b<=10)
  1079.       value2[i]=b-1+'0';
  1080.     else
  1081.       value2[i]=b-1+'A';
  1082.   }
  1083.   for(i=0;i<lng;i++)
  1084.     value[i]=value2[i];
  1085. }
  1086.  
  1087. void generic_compaq(unsigned char *value, const int lng,const unsigned char value_stop)
  1088. {
  1089.   int i,j;
  1090. #ifdef __MSDOS__
  1091.   unsigned char value2[10];
  1092. #else
  1093.   unsigned char value2[lng];
  1094. #endif
  1095.   /* Data from
  1096.    * - Luka "The /\/\ighty \/\/izzy" <cd.roma@flashnet.it>
  1097.    *   Compaq 5200, August 1998
  1098.    * - Quattrocchi Stefano <S.Quattrocchi@tecnimont.it>
  1099.    *   Compaq DeskPro EP Serie 6350/6.4 EA2, May 2001
  1100.    */
  1101.   unsigned char tbl_deco[][4]={
  1102.     {0x00, 0xDD,0x2F,0x02},    /* 1 */
  1103.     {0x80, 0x73,0x13,0x03},    /* 2 */
  1104.     {0x00, 0x3A,0x09,0x04},    /* 3 */
  1105.     {0x80, 0x94,0x35,0x05},    /* 4 */
  1106.     {0x00, 0xE7,0x26,0x06},    /* 5 */
  1107.     {0x80, 0x49,0x1A,0x07},    /* 6 */
  1108.     {0x00, 0x74,0x12,0x08},    /* 7 */
  1109.     {0x80, 0xDA,0x2E,0x09},    /* 8 */
  1110.     {0x00, 0xA9,0x3D,0x0A},    /* 9 */
  1111.     {0x80, 0x07,0x01,0x0B},    /* 0 */
  1112.     {0x00, 0xE8,0x24,0x10},    /* Q */
  1113.     {0x80, 0x46,0x18,0x11},    /* W */
  1114.     {0x00, 0x35,0x0B,0x12},    /* E */
  1115.     {0x80, 0x9B,0x37,0x13},    /* R */
  1116.     {0x00, 0xD2,0x2D,0x14},    /* T */
  1117.     {0x80, 0x7C,0x11,0x15},    /* Y */
  1118.     {0x00, 0x0F,0x02,0x16},    /* U */
  1119.     {0x80, 0xA1,0x3E,0x17},    /* I */
  1120.     {0x00, 0x9C,0x36,0x18},    /* O */
  1121.     {0x80, 0x32,0x0A,0x19},    /* P */
  1122.  
  1123.     {0x00, 0x7B,0x10,0x1E},    /* A */
  1124.     {0x80, 0xD5,0x2C,0x1F},    /* S */
  1125.     {0x00, 0x50,0x1F,0x20},    /* D */
  1126.     {0x80, 0xFE,0x23,0x21},    /* F */
  1127.     {0x00, 0x8D,0x30,0x22},    /* G */
  1128.     {0x80, 0x23,0x0C,0x23},    /* H */
  1129.     {0x00, 0x6A,0x16,0x24},    /* J */
  1130.     {0x80, 0xC4,0x2A,0x25},    /* K */
  1131.     {0x00, 0xB7,0x39,0x26},    /* L */
  1132.  
  1133.     {0x00, 0x1E,0x04,0x2C},    /* Z */
  1134.     {0x80, 0xB0,0x38,0x2D},    /* X */
  1135.     {0x00, 0xC3,0x2B,0x2E},    /* C */
  1136.     {0x80, 0x6D,0x17,0x2F},    /* V */
  1137.     {0x00, 0xB8,0x3B,0x30},    /* B */
  1138.     {0x80, 0x16,0x07,0x31},    /* N */
  1139.     {0x00, 0x65,0x14,0x32},    /* M */
  1140.  
  1141.     {0x80, 0x62,0x15,0x39},    /*   */
  1142.     {0x00, 0x00,0x00,0x00}
  1143.   };
  1144.   for(i=0;i<lng/4;i++)
  1145.   {
  1146.     if((value[4*i+0]==0) && (value[4*i+1]==0) && (value[4*i+2]==0) && (value[4*i+3]==0))
  1147.     {
  1148.       value2[4*i+0]=0x0;
  1149.     }
  1150.     else
  1151.     {
  1152.       /* 1 */
  1153.       value2[4*i+0]=0x3F;    /* => ? */
  1154.       for(j=0;tbl_deco[j][3];j++)
  1155.     if(tbl_deco[j][1] == value[4*i+3])
  1156.     {
  1157.       if((tbl_deco[j][0] & value[4*i+2]) == tbl_deco[j][0])
  1158.       {
  1159.         value2[4*i+0]=tbl_deco[j][3];
  1160.         break;
  1161.       }
  1162.     }
  1163.       /* 2 */
  1164.       value2[4*i+1]=value[4*i+0]^tbl_deco[j][2];
  1165.       //    printf("-%02X-",value2[4*i+1]);
  1166.       /* 3 */
  1167.       value2[4*i+2]=value[4*i+1]&0x7F;
  1168.       /* 4 */
  1169.       value2[4*i+3]=value[4*i+2]&0x7F;
  1170.     }
  1171.   }
  1172.   for(i=0;i<lng;i++)
  1173.     value[i]=value2[i];
  1174. }
  1175.  
  1176.  
  1177. void gateway_ph()
  1178. {    /* Gateway Solo */
  1179.   /*
  1180.   int i;
  1181.   unsigned int crc=0;
  1182.   for(i=0x40;i<0x47;i++)
  1183.   {
  1184.     crc^=scan2ascii(cmos[i]);
  1185.   printf(" %04X ", crc);
  1186.   }
  1187.   CRC inconnu en 5A et 5C
  1188.   */
  1189.   printf(m_gateway_ph);
  1190.   generic_basic(0x40, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  1191.   generic_basic(0x47, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  1192. }
  1193.  
  1194. void phoenixa08()
  1195. {
  1196.   printf(m_phoenixa08);
  1197.   generic_basic(0x23, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  1198.   generic_basic(0x42, 7, METH_PARC_NORMAL,ALGO_NONE,0,AFF_SCAN);
  1199. }
  1200.  
  1201. void toshiba()
  1202. {
  1203.   printf(m_toshiba);
  1204.   generic_crc(ALGO_TOSHIBA,0x35);
  1205.   generic_crc(ALGO_TOSHIBA,0x33);
  1206. }
  1207.  
  1208.  
  1209. void set_permissions()
  1210. {
  1211. #ifdef linux
  1212.   if (ioperm(PORT_CMOS_0,2,IO_READ|IO_WRITE))
  1213.   {
  1214.     printf("Need to be run as root to access the Cmos.\n");
  1215.     exit(1);
  1216.   }
  1217. #elif defined WIN32
  1218.   char OutputBuffer[100];
  1219.   char InputBuffer[100];
  1220. HANDLE h;
  1221.   BOOLEAN bRc;
  1222.   ULONG bytesReturned;
  1223.   h = CreateFile("\\\\.\\gwiopm", GENERIC_READ, 0, NULL,
  1224.                     OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  1225.   if(h == INVALID_HANDLE_VALUE) {
  1226.     printf("Couldn't access gwiopm device\n");
  1227.     exit(2);
  1228.   }
  1229.   memset(OutputBuffer, 0, sizeof(OutputBuffer));
  1230.   InputBuffer[0]=0x70>>3;
  1231.     InputBuffer[1]=0;       /* 0x70 et 0x71 */
  1232.     bRc = DeviceIoControl ( h, 
  1233.                     (DWORD) IOCTL_IOPMD_SET_LIOPM, 
  1234.                     &InputBuffer, 
  1235.                     2, 
  1236.                     &OutputBuffer,
  1237.             sizeof( OutputBuffer),
  1238.             &bytesReturned,
  1239.                     NULL 
  1240.                     );
  1241.     if(bRc!=TRUE)
  1242.         printf("Set_LIOPM failed");
  1243. //IOCTL_IOPMD_ACTIVATE_KIOPM
  1244.     bRc = DeviceIoControl ( h, 
  1245.                     (DWORD) IOCTL_IOPMD_ACTIVATE_KIOPM, 
  1246.                     &InputBuffer, 
  1247.                     2, 
  1248.                     &OutputBuffer,
  1249.             sizeof( OutputBuffer),
  1250.             &bytesReturned,
  1251.                     NULL 
  1252.                     );
  1253.     if(bRc!=TRUE)
  1254.         printf("ACTIVATE_KIOPM failed");
  1255.     CloseHandle(h);
  1256. #elif defined(bsd)
  1257.     cmos_fd = fopen("/dev/io", "r");
  1258.     if(cmos_fd==NULL){
  1259.        perror("fopen /dev/io failed");
  1260.        exit(1);
  1261.     }
  1262. #endif
  1263. }
  1264.  
  1265. void unset_permissions()
  1266. {
  1267. #ifdef linux
  1268.   ioperm(PORT_CMOS_0,2,0);
  1269. #elif defined(bsd)
  1270.   fclose(cmos_fd);
  1271. #endif
  1272. }
  1273.  
  1274. byte read_cmos(const int cell);
  1275. void write_cmos(const int cell, const byte value);
  1276. byte read_cmos(const int cell)
  1277. {
  1278.   outportb(PORT_CMOS_0,cell);
  1279.   return inportb(PORT_CMOS_1);
  1280. }
  1281.  
  1282. void write_cmos(const int cell, const byte value)
  1283. {
  1284.   outportb(PORT_CMOS_0,cell);
  1285.   outportb(PORT_CMOS_1,value);
  1286. }
  1287.  
  1288. int kill_cmos(const int cmos_size)
  1289. {
  1290.   int i;
  1291.   char car;
  1292.   printf("Warning: if the password is stored in an eeprom (notebook), the password won't be erased\n"
  1293.          "\n1 - Kill cmos"
  1294.      "\n2 - Kill cmos (try to keep date and time)"
  1295.      "\n0 - Abort"
  1296.      "\nChoice : ");
  1297.   fflush(stdout);
  1298.   do
  1299.    car=toupper(getchar());
  1300.   while((car<'0')||(car>'2'));
  1301.   fflush(stdout);
  1302.   if(car=='0')
  1303.     return 1;
  1304.   set_permissions();
  1305.   for (i=(car=='1'?0:0x10);i<cmos_size;i++)
  1306.     write_cmos(i,0);
  1307.   unset_permissions();
  1308.   printf("\nCmos killed!");
  1309.   if(car=='1')
  1310.     printf("\nRemember to set date and time");
  1311.   return 0;
  1312. }
  1313.  
  1314. int load_cmos(const int cmos_size)
  1315. {
  1316.   int i;
  1317.   set_permissions();
  1318.   for (i=0;i<cmos_size;i++)
  1319.     cmos[i]=read_cmos(i);
  1320.   unset_permissions();
  1321.   return 0;
  1322. }
  1323.  
  1324. int restore_cmos(const int cmos_size,const int choix)
  1325. {
  1326.   int i;
  1327.   char car='2';
  1328.   if(choix)
  1329.   {
  1330.     printf("\n1 - Restore full cmos"
  1331.       "\n2 - Restore cmos (keep date and time)"
  1332.       "\n0 - Abort"
  1333.       "\nChoice : ");
  1334.     fflush(stdout);
  1335.     do
  1336.     car=toupper(getchar());
  1337.     while((car<'0')||(car>'2'));
  1338.     printf("%c\n", car);
  1339.     fflush(stdout);
  1340.     if(car==0)
  1341.       return 1;
  1342.   }
  1343.   set_permissions();
  1344.   for (i=(car=='1'?0:0x10);i<cmos_size;i++)
  1345.     write_cmos(i,cmos[i]);
  1346.   unset_permissions();
  1347.   if(car=='1')
  1348.     printf("\nRemember to set date and time");
  1349.   return 0;
  1350. }
  1351.  
  1352. int load_backup(const char* name)
  1353. {
  1354.   FILE *fb;
  1355.   unsigned char buffer[TAILLE_BUFFER+1];
  1356.   unsigned int taille,i;
  1357.   int cmos_size=0;
  1358.   fb=fopen(name,"rb");
  1359.   if (fb==0)
  1360.   {
  1361.     printf("\nUnable to read %s\n", name);
  1362.     return -1;
  1363.   }
  1364.   taille=fread(buffer,1, TAILLE_BUFFER,fb);
  1365.   fclose(fb);
  1366.   if((taille==64)||(taille==128)||(taille==256))
  1367.   {
  1368.     printf("\nRead a %d byte cmos backup (%s)",taille, name);
  1369.     for(i=0;i<taille;i++)
  1370.       cmos[i]=buffer[i];
  1371.     cmos_size=taille;
  1372.   }
  1373.   else
  1374.   if((taille==64-0x10)||(taille==128-0x10)||(taille==256-0x10))
  1375.   {
  1376.     printf("\nRead a %d byte cmos backup, first 16 byte skipped",taille);
  1377.     for(i=0x10;i<taille;i++)
  1378.       cmos[i]=buffer[i-0x10];
  1379.     cmos_size=taille+0x10;
  1380.   }
  1381.   else
  1382.   if(taille==0x400+TAILLE_CMOS-0x10)
  1383.   {
  1384.     printf("\nRead a cmos backup from a SAUVER file");
  1385.     for(i=0x10;i<TAILLE_CMOS;i++)
  1386.       cmos[i]=buffer[0x400+i-0x10];
  1387.     cmos_size=TAILLE_CMOS;
  1388.   }
  1389.   else
  1390.   if(taille==129)
  1391.   {
  1392.     printf("\nRead a %d byte cmos !BIOS backup (%s)",taille, name);
  1393.     for(i=0;i<taille;i++)
  1394.       cmos[i]=buffer[i];
  1395.     cmos_size=TAILLE_CMOS;
  1396.   }
  1397.   else
  1398.   {
  1399.     printf("\nUnknown file format");
  1400.     for(i=0;i<taille;i++)
  1401.       cmos[i]=buffer[i];
  1402.     cmos_size=taille;
  1403.   }
  1404.   return cmos_size;
  1405. }
  1406.  
  1407. int save_backup(const int cmos_size, const char* name)
  1408. {
  1409.   FILE *fb;
  1410.   fb=fopen(name,"wb");
  1411.   if (fb==0)
  1412.   {
  1413.     printf("\nUnable to create %s", name);
  1414.     return 1;
  1415.   }
  1416.   if(fwrite(cmos,1, cmos_size,fb)!=cmos_size)
  1417.   {
  1418.     printf("\nWrite error");
  1419.     return 1;
  1420.   }
  1421.   fclose(fb);
  1422.   return 0;
  1423. }
  1424.  
  1425. #ifdef linux
  1426. void award_backdoor()
  1427. {
  1428.   int i;
  1429.   char car;
  1430.   FILE *fb;
  1431.   fb=fopen("/dev/mem","r");
  1432.   if(!fb)
  1433.     return ;
  1434.   fseek(fb,(0xF000<<4)+0xEC60,SEEK_SET);
  1435.   for(i=0;i<8;i++)
  1436.   {
  1437.     fread(&car,1,1,fb);
  1438.     printf("%c",(car<<5)|(car>>5)|(car&0x18));
  1439.   }
  1440. #ifdef ESSAI
  1441.   fseek(fb,(0xF000<<4)+0xFFF0,SEEK_SET);
  1442.   for(i=0;i<0x10;i++)
  1443.   {
  1444.     fread(&car,1,1,fb);
  1445.     printf("%c", car);
  1446.   }
  1447. #endif
  1448.   fclose(fb);
  1449. }
  1450. #endif
  1451.  
  1452. /* MAIN PROGRAM */
  1453. int main(int argc, char *argv[])
  1454. {
  1455.   int pos_name=-1;
  1456.   int do_dump=0;
  1457.   int module_arg=0;
  1458.   int cmos_size=0x80;
  1459.   enum {MODE_NORM,MODE_HELP,MODE_LOAD, MODE_SAVE, MODE_KILL, MODE_RESTORE, MODE_RESTORE_FORCE} mode=MODE_NORM;
  1460.   printf("\nCmosPwd - BIOS Cracker 4.0, Februar 7 2002, Copyright 1996-2002"
  1461.      "\nGRENIER Christophe, grenier@cgsecurity.org"
  1462.      "\nhttp://www.cgsecurity.org/\n");
  1463.   {
  1464.     int i;
  1465.     for(i=1;i<argc;i++)
  1466.     {
  1467.       if((pos_name==-1)&&((mode==MODE_LOAD)||(mode==MODE_SAVE)||(mode==MODE_RESTORE)||(mode==MODE_RESTORE_FORCE)))
  1468.     pos_name=i;
  1469.       else
  1470.     if(strcmp(argv[i],"/kfr")==0)
  1471.       keyb=KEYB_FR;
  1472.     else
  1473.       if(strcmp(argv[i],"/kde")==0)
  1474.         keyb=KEYB_DE;
  1475.       else
  1476.         if(strcmp(argv[i],"/d")==0)
  1477.           do_dump=1;
  1478.         else
  1479.           if(strcmp(argv[i],"/r")==0)
  1480.           {
  1481.         if(mode) mode=MODE_HELP; else mode=MODE_RESTORE;
  1482.           }
  1483.           else
  1484.         if(strcmp(argv[i],"/R")==0)
  1485.         {
  1486.           if(mode) mode=MODE_HELP; else mode=MODE_RESTORE_FORCE;
  1487.         }
  1488.         else
  1489.           if(strcmp(argv[i],"/l")==0)
  1490.           {
  1491.             if(mode) mode=MODE_HELP; else mode=MODE_LOAD;
  1492.           }
  1493.           else
  1494.             if((strcmp(argv[i],"/w")==0)||(strcmp(argv[i],"/s")==0))
  1495.             {
  1496.               if(mode) mode=MODE_HELP; else mode=MODE_SAVE;
  1497.             }
  1498.             else
  1499.               if(strcmp(argv[i],"/k")==0)
  1500.               {
  1501.             if(mode) mode=MODE_HELP; else mode=MODE_KILL;
  1502.               }
  1503.               else
  1504.             if(strncmp(argv[i],"/m",2)==0)
  1505.               module_arg=i;
  1506.             else
  1507.               mode=MODE_HELP;
  1508.       if(mode==MODE_HELP)
  1509.     break;
  1510.     }
  1511.   }
  1512.   if((pos_name==-1)&&((mode==MODE_LOAD)||(mode==MODE_SAVE)||(mode==MODE_RESTORE)||(mode==MODE_RESTORE_FORCE)))
  1513.   {
  1514.     printf("\nPlease choose a cmos backup file\n");
  1515.     return 1;
  1516.   }
  1517.   memset(cmos, 0, sizeof(cmos));
  1518.   switch(mode)
  1519.   {
  1520.     case MODE_HELP:
  1521.       printf(
  1522.       "\nUsage: cmospwd [/k[de|fr]] [/d]"
  1523.       "\n       cmospwd [/k[de|fr]] [/d] /[rlw] cmos_backup_file           restore/load/write"
  1524.       "\n       cmospwd /k                                          kill cmos"
  1525.       "\n       cmospwd [/k[de|fr]] /m[01]*    execute selected module"
  1526.       "\n"
  1527.       "\n /kfr french AZERTY keyboard, /kde german QWERTY keyboard"
  1528.       "\n /d to dump cmos"
  1529.       "\n /m0010011 to execute module 3,6 and 7"
  1530.       "\n"
  1531.       "\nNB: For Award BIOS, passwords are differents than original, but work."
  1532.       "\n");
  1533.       return 0;
  1534.     case MODE_KILL:
  1535.       return kill_cmos(cmos_size);
  1536.     case MODE_LOAD:
  1537.       if((cmos_size=load_backup(argv[pos_name]))<0)
  1538.     return 1;
  1539.       break;
  1540.     case MODE_RESTORE:
  1541.       if((cmos_size=load_backup(argv[pos_name]))<0)
  1542.     return 1;
  1543.       return restore_cmos(cmos_size,1);
  1544.     case MODE_RESTORE_FORCE:
  1545.       if((cmos_size=load_backup(argv[pos_name]))<0)
  1546.     return 1;
  1547.       return restore_cmos(cmos_size,0);
  1548.     default:
  1549.       if(load_cmos(cmos_size))
  1550.     return 1;
  1551.       if(mode==MODE_SAVE)
  1552.     return save_backup(cmos_size,argv[pos_name]);
  1553.       break;
  1554.   }
  1555.   switch(keyb)
  1556.   {
  1557.     case KEYB_FR:
  1558.       printf("\nKeyboard : FR");
  1559.       break;
  1560.     case KEYB_DE:
  1561.       printf("\nKeyboard : DE");
  1562.       break;
  1563.     case KEYB_US:
  1564.     default:
  1565.       printf("\nKeyboard : US");
  1566.       break;
  1567.   }
  1568.   if(module_arg)
  1569.   {
  1570.     unsigned int i;
  1571.     for(i=2;argv[module_arg][i] && (i<nbr_func+2);i++)
  1572.     {
  1573.       if(argv[module_arg][i]=='1')
  1574.     tbl_func[i-2]();
  1575.     }
  1576.   }
  1577.   else
  1578.   {
  1579.     unsigned int i;
  1580.     for(i=0;i<nbr_func;i++)
  1581.     {
  1582.       if(i==15)
  1583.       {
  1584.     printf("\nPress a key to continue");
  1585.     getchar();
  1586.       }
  1587.       tbl_func[i]();
  1588.     }
  1589.   }
  1590.   if(do_dump)
  1591.   {
  1592.     printf("\n\nPress a key to continue\n");
  1593.     fflush(stdout);
  1594.     getchar();
  1595.     printf("\nDump cmos");
  1596.     dumpcmos(cmos_size,0);
  1597.     printf("\nDump cmos (Scan code convertion)");
  1598.     dumpcmos(cmos_size,1);
  1599.   }
  1600. #if defined(WIN32) || defined(linux)
  1601.   printf("\n");
  1602.   fflush(stdout);
  1603. #endif
  1604. #ifdef linux
  1605. //  award_backdoor();
  1606. #endif
  1607.   return 0;
  1608. }
  1609.