home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / libmysql / password.c < prev    next >
C/C++ Source or Header  |  2000-08-31  |  6KB  |  193 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This library is free software; you can redistribute it and/or
  4.    modify it under the terms of the GNU Library General Public
  5.    License as published by the Free Software Foundation; either
  6.    version 2 of the License, or (at your option) any later version.
  7.    
  8.    This library is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11.    Library General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; if not, write to the Free
  15.    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16.    MA 02111-1307, USA */
  17.  
  18. /* password checking routines */
  19. /*****************************************************************************
  20.   The main idea is that no password are sent between client & server on
  21.   connection and that no password are saved in mysql in a decodable form.
  22.  
  23.   On connection a random string is generated and sent to the client.
  24.   The client generates a new string with a random generator inited with
  25.   the hash values from the password and the sent string.
  26.   This 'check' string is sent to the server where it is compared with
  27.   a string generated from the stored hash_value of the password and the
  28.   random string.
  29.  
  30.   The password is saved (in user.password) by using the PASSWORD() function in
  31.   mysql.
  32.  
  33.   Example:
  34.     update user set password=PASSWORD("hello") where user="test"
  35.   This saves a hashed number as a string in the password field.
  36. *****************************************************************************/
  37.  
  38. #include <global.h>
  39. #include <my_sys.h>
  40. #include <m_string.h>
  41. #include "mysql.h"
  42.  
  43.  
  44. void randominit(struct rand_struct *rand_st,ulong seed1, ulong seed2)
  45. {                        /* For mysql 3.21.# */
  46. #ifdef HAVE_purify
  47.   bzero((char*) rand_st,sizeof(*rand_st));        /* Avoid UMC varnings */
  48. #endif
  49.   rand_st->max_value= 0x3FFFFFFFL;
  50.   rand_st->max_value_dbl=(double) rand_st->max_value;
  51.   rand_st->seed1=seed1%rand_st->max_value ;
  52.   rand_st->seed2=seed2%rand_st->max_value;
  53. }
  54.  
  55. static void old_randominit(struct rand_struct *rand_st,ulong seed1)
  56. {                        /* For mysql 3.20.# */
  57.   rand_st->max_value= 0x01FFFFFFL;
  58.   rand_st->max_value_dbl=(double) rand_st->max_value;
  59.   seed1%=rand_st->max_value;
  60.   rand_st->seed1=seed1 ; rand_st->seed2=seed1/2;
  61. }
  62.  
  63. double rnd(struct rand_struct *rand_st)
  64. {
  65.   rand_st->seed1=(rand_st->seed1*3+rand_st->seed2) % rand_st->max_value;
  66.   rand_st->seed2=(rand_st->seed1+rand_st->seed2+33) % rand_st->max_value;
  67.   return (((double) rand_st->seed1)/rand_st->max_value_dbl);
  68. }
  69.  
  70. void hash_password(ulong *result, const char *password)
  71. {
  72.   register ulong nr=1345345333L, add=7, nr2=0x12345671L;
  73.   ulong tmp;
  74.   for (; *password ; password++)
  75.   {
  76.     if (*password == ' ' || *password == '\t')
  77.       continue;            /* skipp space in password */
  78.     tmp= (ulong) (uchar) *password;
  79.     nr^= (((nr & 63)+add)*tmp)+ (nr << 8);
  80.     nr2+=(nr2 << 8) ^ nr;
  81.     add+=tmp;
  82.   }
  83.   result[0]=nr & (((ulong) 1L << 31) -1L); /* Don't use sign bit (str2int) */;
  84.   result[1]=nr2 & (((ulong) 1L << 31) -1L);
  85.   return;
  86. }
  87.  
  88. void make_scrambled_password(char *to,const char *password)
  89. {
  90.   ulong hash_res[2];
  91.   hash_password(hash_res,password);
  92.   sprintf(to,"%08lx%08lx",hash_res[0],hash_res[1]);
  93. }
  94.  
  95. static inline uint char_val(char X)
  96. {
  97.   return (uint) (X >= '0' && X <= '9' ? X-'0' :
  98.          X >= 'A' && X <= 'Z' ? X-'A'+10 :
  99.          X-'a'+10);
  100. }
  101.  
  102. /*
  103. ** This code assumes that len(password) is divideable with 8 and that
  104. ** res is big enough (2 in mysql)
  105. */
  106.  
  107. void get_salt_from_password(ulong *res,const char *password)
  108. {
  109.   res[0]=res[1]=0;
  110.   if (password)
  111.   {
  112.     while (*password)
  113.     {
  114.       ulong val=0;
  115.       uint i;
  116.       for (i=0 ; i < 8 ; i++)
  117.     val=(val << 4)+char_val(*password++);
  118.       *res++=val;
  119.     }
  120.   }
  121.   return;
  122. }
  123.  
  124. void make_password_from_salt(char *to, ulong *hash_res)
  125. {
  126.   sprintf(to,"%08lx%08lx",hash_res[0],hash_res[1]);
  127. }
  128.  
  129.  
  130. /*
  131.  * Genererate a new message based on message and password
  132.  * The same thing is done in client and server and the results are checked.
  133.  */
  134.  
  135. char *scramble(char *to,const char *message,const char *password,
  136.            my_bool old_ver)
  137. {
  138.   struct rand_struct rand_st;
  139.   ulong hash_pass[2],hash_message[2];
  140.   if (password && password[0])
  141.   {
  142.     char *to_start=to;
  143.     hash_password(hash_pass,password);
  144.     hash_password(hash_message,message);
  145.     if (old_ver)
  146.       old_randominit(&rand_st,hash_pass[0] ^ hash_message[0]);
  147.     else
  148.       randominit(&rand_st,hash_pass[0] ^ hash_message[0],
  149.          hash_pass[1] ^ hash_message[1]);
  150.     while (*message++)
  151.       *to++= (char) (floor(rnd(&rand_st)*31)+64);
  152.     if (!old_ver)
  153.     {                        /* Make it harder to break */
  154.       char extra=(char) (floor(rnd(&rand_st)*31));
  155.       while (to_start != to)
  156.     *(to_start++)^=extra;
  157.     }
  158.   }
  159.   *to=0;
  160.   return to;
  161. }
  162.  
  163.  
  164. my_bool check_scramble(const char *scrambled, const char *message,
  165.                ulong *hash_pass, my_bool old_ver)
  166. {
  167.   struct rand_struct rand_st;
  168.   ulong hash_message[2];
  169.   char buff[16],*to,extra;            /* Big enough for check */
  170.   const char *pos;
  171.  
  172.   hash_password(hash_message,message);
  173.   if (old_ver)
  174.     old_randominit(&rand_st,hash_pass[0] ^ hash_message[0]);
  175.   else
  176.     randominit(&rand_st,hash_pass[0] ^ hash_message[0],
  177.            hash_pass[1] ^ hash_message[1]);
  178.   to=buff;
  179.   for (pos=scrambled ; *pos ; pos++)
  180.     *to++=(char) (floor(rnd(&rand_st)*31)+64);
  181.   if (old_ver)
  182.     extra=0;
  183.   else
  184.     extra=(char) (floor(rnd(&rand_st)*31));
  185.   to=buff;
  186.   while (*scrambled)
  187.   {
  188.     if (*scrambled++ != (char) (*to++ ^ extra))
  189.       return 1;                    /* Wrong password */
  190.   }
  191.   return 0;
  192. }
  193.