Line data    Source code

       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             :    smbpasswd file format routines
       4             : 
       5             :    Copyright (C) Andrew Tridgell 1992-1998 
       6             :    Modified by Jeremy Allison 1995.
       7             :    Modified by Gerald (Jerry) Carter 2000-2001
       8             :    Copyright (C) Tim Potter 2001
       9             :    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
      10             :    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2005
      11             :    
      12             :    This program is free software; you can redistribute it and/or modify
      13             :    it under the terms of the GNU General Public License as published by
      14             :    the Free Software Foundation; either version 3 of the License, or
      15             :    (at your option) any later version.
      16             :    
      17             :    This program is distributed in the hope that it will be useful,
      18             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      19             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      20             :    GNU General Public License for more details.
      21             :    
      22             :    You should have received a copy of the GNU General Public License
      23             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      24             : */
      25             : 
      26             : /*! \file lib/smbpasswd.c
      27             : 
      28             :    The smbpasswd file is used to store encrypted passwords in a similar
      29             :    fashion to the /etc/passwd file.  The format is colon separated fields
      30             :    with one user per line like so:
      31             : 
      32             :    <username>:<uid>:<lanman hash>:<nt hash>:<acb info>:<last change time>
      33             : 
      34             :    The username and uid must correspond to an entry in the /etc/passwd
      35             :    file.  The lanman and nt password hashes are 32 hex digits corresponding
      36             :    to the 16-byte lanman and nt hashes respectively.  
      37             : 
      38             :    The password last change time is stored as a string of the format
      39             :    LCD-<change time> where the change time is expressed as an 
      40             : 
      41             :    'N'    No password
      42             :    'D'    Disabled
      43             :    'H'    Homedir required
      44             :    'T'    Temp account.
      45             :    'U'    User account (normal) 
      46             :    'M'    MNS logon user account - what is this ? 
      47             :    'W'    Workstation account
      48             :    'S'    Server account 
      49             :    'L'    Locked account
      50             :    'X'    No Xpiry on password 
      51             :    'I'    Interdomain trust account
      52             : 
      53             : */
      54             : 
      55             : #include "includes.h"
      56             : #include "system/locale.h"
      57             : #include "lib/samba3/samba3.h"
      58             : 
      59             : /*! Convert 32 hex characters into a 16 byte array. */
      60             : 
      61           0 : struct samr_Password *smbpasswd_gethexpwd(TALLOC_CTX *mem_ctx, const char *p)
      62             : {
      63             :         int i;
      64             :         unsigned char   lonybble, hinybble;
      65           0 :         const char     *hexchars = "0123456789ABCDEF";
      66             :         const char     *p1, *p2;
      67           0 :         struct samr_Password *pwd = talloc(mem_ctx, struct samr_Password);
      68             : 
      69           0 :         if (!p) return NULL;
      70             :         
      71           0 :         for (i = 0; i < (sizeof(pwd->hash) * 2); i += 2)
      72             :         {
      73           0 :                 hinybble = toupper(p[i]);
      74           0 :                 lonybble = toupper(p[i + 1]);
      75             :                 
      76           0 :                 p1 = strchr_m(hexchars, hinybble);
      77           0 :                 p2 = strchr_m(hexchars, lonybble);
      78             :                 
      79           0 :                 if (!p1 || !p2) {
      80           0 :                         return NULL;
      81             :                 }
      82             :                 
      83           0 :                 hinybble = PTR_DIFF(p1, hexchars);
      84           0 :                 lonybble = PTR_DIFF(p2, hexchars);
      85             :                 
      86           0 :                 pwd->hash[i / 2] = (hinybble << 4) | lonybble;
      87             :         }
      88           0 :         return pwd;
      89             : }
      90             : 
      91             : /*! Convert a 16-byte array into 32 hex characters. */
      92           0 : char *smbpasswd_sethexpwd(TALLOC_CTX *mem_ctx, struct samr_Password *pwd, uint16_t acb_info)
      93             : {
      94             :         char *p;
      95           0 :         if (pwd != NULL) {
      96             :                 int i;
      97           0 :                 p = talloc_array(mem_ctx, char, 33);
      98           0 :                 if (!p) {
      99           0 :                         return NULL;
     100             :                 }
     101             : 
     102           0 :                 for (i = 0; i < sizeof(pwd->hash); i++)
     103           0 :                         slprintf(&p[i*2], 3, "%02X", pwd->hash[i]);
     104             :         } else {
     105           0 :                 if (acb_info & ACB_PWNOTREQ)
     106           0 :                         p = talloc_strdup(mem_ctx, "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX");
     107             :                 else
     108           0 :                         p = talloc_strdup(mem_ctx, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
     109             :         }
     110           0 :         return p;
     111             : }