1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
4
* Copyright (C) 2008 Sun Microsystems, Inc.
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; version 2 of the License.
10
* This program is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
* GNU General Public License for more details.
15
* You should have received a copy of the GNU General Public License
16
* along with this program; if not, write to the Free Software
17
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1
/* Copyright (C) 2000-2006 MySQL AB
3
This program is free software; you can redistribute it and/or modify
4
it under the terms of the GNU General Public License as published by
5
the Free Software Foundation; version 2 of the License.
7
This program is distributed in the hope that it will be useful,
8
but WITHOUT ANY WARRANTY; without even the implied warranty of
9
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10
GNU General Public License for more details.
12
You should have received a copy of the GNU General Public License
13
along with this program; if not, write to the Free Software
14
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
20
16
/* password checking routines */
21
17
/*****************************************************************************
115
114
password_len IN password length (password may be not null-terminated)
118
void hash_password(uint32_t *result, const char *password, uint32_t password_len)
117
void hash_password(ulong *result, const char *password, uint password_len)
120
register uint32_t nr=1345345333L, add=7, nr2=0x12345671L;
119
register ulong nr=1345345333L, add=7, nr2=0x12345671L;
122
121
const char *password_end= password + password_len;
123
122
for (; password < password_end; password++)
125
124
if (*password == ' ' || *password == '\t')
126
125
continue; /* skip space in password */
127
tmp= (uint32_t) (unsigned char) *password;
126
tmp= (ulong) (uchar) *password;
128
127
nr^= (((nr & 63)+add)*tmp)+ (nr << 8);
129
128
nr2+=(nr2 << 8) ^ nr;
132
result[0]=nr & (((uint32_t) 1L << 31) -1L); /* Don't use sign bit (str2int) */;
133
result[1]=nr2 & (((uint32_t) 1L << 31) -1L);
136
static inline uint8_t char_val(uint8_t X)
138
return (uint32_t) (X >= '0' && X <= '9' ? X-'0' :
131
result[0]=nr & (((ulong) 1L << 31) -1L); /* Don't use sign bit (str2int) */;
132
result[1]=nr2 & (((ulong) 1L << 31) -1L);
137
Create password to be stored in user database from raw string
138
Used for pre-4.1 password handling
140
make_scrambled_password_323()
141
to OUT store scrambled password here
142
password IN user-supplied password
145
void make_scrambled_password_323(char *to, const char *password)
148
hash_password(hash_res, password, (uint) strlen(password));
149
sprintf(to, "%08lx%08lx", hash_res[0], hash_res[1]);
154
Scramble string with password.
155
Used in pre 4.1 authentication phase.
158
to OUT Store scrambled message here. Buffer must be at least
159
SCRAMBLE_LENGTH_323+1 bytes long
160
message IN Message to scramble. Message must be at least
161
SRAMBLE_LENGTH_323 bytes long.
162
password IN Password to use while scrambling
165
void scramble_323(char *to, const char *message, const char *password)
167
struct rand_struct rand_st;
168
ulong hash_pass[2], hash_message[2];
170
if (password && password[0])
172
char extra, *to_start=to;
173
const char *message_end= message + SCRAMBLE_LENGTH_323;
174
hash_password(hash_pass,password, (uint) strlen(password));
175
hash_password(hash_message, message, SCRAMBLE_LENGTH_323);
176
randominit(&rand_st,hash_pass[0] ^ hash_message[0],
177
hash_pass[1] ^ hash_message[1]);
178
for (; message < message_end; message++)
179
*to++= (char) (floor(my_rnd(&rand_st)*31)+64);
180
extra=(char) (floor(my_rnd(&rand_st)*31));
181
while (to_start != to)
182
*(to_start++)^=extra;
189
Check scrambled message
190
Used in pre 4.1 password handling
193
scrambled scrambled message to check.
194
message original random message which was used for scrambling; must
195
be exactly SCRAMBLED_LENGTH_323 bytes long and
197
hash_pass password which should be used for scrambling
202
!0 - password invalid
206
check_scramble_323(const char *scrambled, const char *message,
209
struct rand_struct rand_st;
210
ulong hash_message[2];
211
char buff[16],*to,extra; /* Big enough for check */
214
hash_password(hash_message, message, SCRAMBLE_LENGTH_323);
215
randominit(&rand_st,hash_pass[0] ^ hash_message[0],
216
hash_pass[1] ^ hash_message[1]);
218
DBUG_ASSERT(sizeof(buff) > SCRAMBLE_LENGTH_323);
219
for (pos=scrambled ; *pos && to < buff+sizeof(buff) ; pos++)
220
*to++=(char) (floor(my_rnd(&rand_st)*31)+64);
221
if (pos-scrambled != SCRAMBLE_LENGTH_323)
223
extra=(char) (floor(my_rnd(&rand_st)*31));
227
if (*scrambled++ != (char) (*to++ ^ extra))
228
return 1; /* Wrong password */
233
static inline uint8 char_val(uint8 X)
235
return (uint) (X >= '0' && X <= '9' ? X-'0' :
139
236
X >= 'A' && X <= 'Z' ? X-'A'+10 : X-'a'+10);
241
Convert password from hex string (as stored in mysql.user) to binary form.
243
get_salt_from_password_323()
244
res OUT store salt here
245
password IN password string as stored in mysql.user
247
This function does not have length check for passwords. It will just crash
248
Password hashes in old format must have length divisible by 8
251
void get_salt_from_password_323(ulong *res, const char *password)
260
for (i=0 ; i < 8 ; i++)
261
val=(val << 4)+char_val(*password++);
269
Convert scrambled password from binary form to asciiz hex string.
271
make_password_from_salt_323()
272
to OUT store resulting string password here, at least 17 bytes
273
salt IN password in salt format, 2 ulongs
276
void make_password_from_salt_323(char *to, const ulong *salt)
278
sprintf(to,"%08lx%08lx", salt[0], salt[1]);
144
283
**************** MySQL 4.1.1 authentication routines *************
184
char *octet2hex(char *to, const char *str, uint32_t len)
323
char *octet2hex(char *to, const char *str, uint len)
186
325
const char *str_end= str + len;
187
326
for (; str != str_end; ++str)
189
*to++= _dig_vec_upper[((unsigned char) *str) >> 4];
190
*to++= _dig_vec_upper[((unsigned char) *str) & 0x0F];
328
*to++= _dig_vec_upper[((uchar) *str) >> 4];
329
*to++= _dig_vec_upper[((uchar) *str) & 0x0F];
337
Convert given asciiz string of hex (0..9 a..f) characters to octet
341
to OUT buffer to place result; must be at least len/2 bytes
342
str, len IN begin, length for character string; str and to may not
343
overlap; len % 2 == 0
347
hex2octet(uint8 *to, const char *str, uint len)
349
const char *str_end= str + len;
350
while (str < str_end)
352
register char tmp= char_val(*str++);
353
*to++= (tmp << 4) | char_val(*str++);
359
Encrypt/Decrypt function used for password encryption in authentication.
360
Simple XOR is used here but it is OK as we crypt random strings. Note,
361
that XOR(s1, XOR(s1, s2)) == s2, XOR(s1, s2) == XOR(s2, s1)
364
to OUT buffer to hold crypted string; must be at least len bytes
365
long; to and s1 (or s2) may be the same.
366
s1, s2 IN input strings (of equal length)
367
len IN length of s1 and s2
371
my_crypt(char *to, const uchar *s1, const uchar *s2, uint len)
373
const uint8 *s1_end= s1 + len;
375
*to++= *s1++ ^ *s2++;
380
MySQL 4.1.1 password hashing: SHA conversion (see RFC 2289, 3174) twice
381
applied to the password string, and then produced octet sequence is
382
converted to hex string.
383
The result of this function is used as return value from PASSWORD() and
384
is stored in the database.
386
make_scrambled_password()
387
buf OUT buffer of size 2*SHA1_HASH_SIZE + 2 to store hex string
388
password IN NULL-terminated password string
392
make_scrambled_password(char *to, const char *password)
394
SHA1_CONTEXT sha1_context;
395
uint8 hash_stage2[SHA1_HASH_SIZE];
397
mysql_sha1_reset(&sha1_context);
398
/* stage 1: hash password */
399
mysql_sha1_input(&sha1_context, (uint8 *) password, (uint) strlen(password));
400
mysql_sha1_result(&sha1_context, (uint8 *) to);
401
/* stage 2: hash stage1 output */
402
mysql_sha1_reset(&sha1_context);
403
mysql_sha1_input(&sha1_context, (uint8 *) to, SHA1_HASH_SIZE);
404
/* separate buffer is used to pass 'to' in octet2hex */
405
mysql_sha1_result(&sha1_context, hash_stage2);
406
/* convert hash_stage2 to hex string */
407
*to++= PVERSION41_CHAR;
408
octet2hex(to, (const char*) hash_stage2, SHA1_HASH_SIZE);
413
Produce an obscure octet sequence from password and random
414
string, recieved from the server. This sequence corresponds to the
415
password, but password can not be easily restored from it. The sequence
416
is then sent to the server for validation. Trailing zero is not stored
417
in the buf as it is not needed.
418
This function is used by client to create authenticated reply to the
422
buf OUT store scrambled string here. The buf must be at least
423
SHA1_HASH_SIZE bytes long.
424
message IN random message, must be exactly SCRAMBLE_LENGTH long and
426
password IN users' password
430
scramble(char *to, const char *message, const char *password)
432
SHA1_CONTEXT sha1_context;
433
uint8 hash_stage1[SHA1_HASH_SIZE];
434
uint8 hash_stage2[SHA1_HASH_SIZE];
436
mysql_sha1_reset(&sha1_context);
437
/* stage 1: hash password */
438
mysql_sha1_input(&sha1_context, (uint8 *) password, (uint) strlen(password));
439
mysql_sha1_result(&sha1_context, hash_stage1);
440
/* stage 2: hash stage 1; note that hash_stage2 is stored in the database */
441
mysql_sha1_reset(&sha1_context);
442
mysql_sha1_input(&sha1_context, hash_stage1, SHA1_HASH_SIZE);
443
mysql_sha1_result(&sha1_context, hash_stage2);
444
/* create crypt string as sha1(message, hash_stage2) */;
445
mysql_sha1_reset(&sha1_context);
446
mysql_sha1_input(&sha1_context, (const uint8 *) message, SCRAMBLE_LENGTH);
447
mysql_sha1_input(&sha1_context, hash_stage2, SHA1_HASH_SIZE);
448
/* xor allows 'from' and 'to' overlap: lets take advantage of it */
449
mysql_sha1_result(&sha1_context, (uint8 *) to);
450
my_crypt(to, (const uchar *) to, hash_stage1, SCRAMBLE_LENGTH);
455
Check that scrambled message corresponds to the password; the function
456
is used by server to check that recieved reply is authentic.
457
This function does not check lengths of given strings: message must be
458
null-terminated, reply and hash_stage2 must be at least SHA1_HASH_SIZE
459
long (if not, something fishy is going on).
462
scramble clients' reply, presumably produced by scramble()
463
message original random string, previously sent to client
464
(presumably second argument of scramble()), must be
465
exactly SCRAMBLE_LENGTH long and NULL-terminated.
466
hash_stage2 hex2octet-decoded database entry
470
0 password is correct
471
!0 password is invalid
475
check_scramble(const char *scramble_arg, const char *message,
476
const uint8 *hash_stage2)
478
SHA1_CONTEXT sha1_context;
479
uint8 buf[SHA1_HASH_SIZE];
480
uint8 hash_stage2_reassured[SHA1_HASH_SIZE];
482
mysql_sha1_reset(&sha1_context);
483
/* create key to encrypt scramble */
484
mysql_sha1_input(&sha1_context, (const uint8 *) message, SCRAMBLE_LENGTH);
485
mysql_sha1_input(&sha1_context, hash_stage2, SHA1_HASH_SIZE);
486
mysql_sha1_result(&sha1_context, buf);
487
/* encrypt scramble */
488
my_crypt((char *) buf, buf, (const uchar *) scramble_arg, SCRAMBLE_LENGTH);
489
/* now buf supposedly contains hash_stage1: so we can get hash_stage2 */
490
mysql_sha1_reset(&sha1_context);
491
mysql_sha1_input(&sha1_context, buf, SHA1_HASH_SIZE);
492
mysql_sha1_result(&sha1_context, hash_stage2_reassured);
493
return memcmp(hash_stage2, hash_stage2_reassured, SHA1_HASH_SIZE);
498
Convert scrambled password from asciiz hex string to binary form.
501
get_salt_from_password()
502
res OUT buf to hold password. Must be at least SHA1_HASH_SIZE
504
password IN 4.1.1 version value of user.password
507
void get_salt_from_password(uint8 *hash_stage2, const char *password)
509
hex2octet(hash_stage2, password+1 /* skip '*' */, SHA1_HASH_SIZE * 2);
513
Convert scrambled password from binary form to asciiz hex string.
515
make_password_from_salt()
516
to OUT store resulting string here, 2*SHA1_HASH_SIZE+2 bytes
517
salt IN password in salt format
520
void make_password_from_salt(char *to, const uint8 *hash_stage2)
522
*to++= PVERSION41_CHAR;
523
octet2hex(to, (const char*) hash_stage2, SHA1_HASH_SIZE);
added
removed
libdrizzle/password.c
