Logging in, part 2

As I do not have access to the VMS or LOGINOUT program source code, and there is no documentation for a service to log users in, I am unsure as to exact nature of how VMS logs users in. One possible mechanism might be to have the LOGIN program do the user authentication and then use CREPRC to create a process logged in to the user's account. The problem with that approach is that there would still need to be a mechanism for LOGIN to validate the password - either to get the password from the UAF and do a comparison, or else to make a call to have the system validate a password. However, the first option isn't secure - no program ought to be able to interrogate the UAF for a password. The second option simply pushes the problem to a non-existent/unknown system service.

UOS will handle this situation by introducing a new system routine: the SYS_LOGIN service. As we will shortly discover, this routine can only be called from the LOGIN CUSP since the routine only operates for a process that has no user defined and only LOGIN runs on a process that has no defined user. For this reason, we won't bother to provide user documentation for SYS_LOGIN.

function SYS_LOGIN( User, Pass : int64 ) : int64 ;

var SRB_U, SRB_P : PSRB ;
    Status : int64 ;
    SysRequest : TString2_Request ;

begin
    fillchar( SysRequest, sizeof( SysRequest ), 0 ) ;
    Status := 0 ;
    SysRequest.Request.Subsystem :=  UOS_Subsystem_USC ;
    SysRequest.Request.Request := UOS_USC_Login ;
    SysRequest.Request.Length := sizeof( SysRequest ) - sizeof( Sysrequest.Request ) ;
    SysRequest.Request.Status := integer( @Status ) ;
    if( User <> 0 ) then
    begin
        SRB_U := PSRB( User ) ;
        SysRequest.String1.Buffer := SRB_U.Buffer ;
        SysRequest.String1.Length := SRB_U.Length ;
    end ;
    if( Pass <> 0 ) then
    begin
        SRB_P := PSRB( Pass ) ;
        SysRequest.String2.Buffer := SRB_P.Buffer ;
        SysRequest.String2.Length := SRB_P.Length ;
    end ;

    Call_To_Ring0( integer( @SysRequest ) ) ;

    Result := Status ;
end ;

This addition to the SYS unit is the wrapper for the system LOGIN service. It is like other wrappers in this unit.

        UOS_USC_Login:
            begin
                UE := Enter_System_Call( Request, SReq, PID, MMC, sizeof( S2_Request ) - sizeof( SReq ), 
                    Address ) ;
                if( UE <> nil ) then
                begin
                    Set_Last_Error( UE ) ;
                    exit ;
                end ;
                try
                    S2_Request := PString2_Request( Address ) ;
                    Log_In( S2_Request.String1, S2_Request.String2, IOSB ) ;
                    Write_User( Kernel, PID, S2_Request.Request.Status, sizeof( IOSB.r_io_64.w_status ), 
                        IOSB.r_io_64.w_status ) ;
                finally
                    Exit_System_Call( Request, PID, MMC, sizeof( S2_Request ) - sizeof( SReq ) ) ;
                end ;
            end ;

This code is added to the USC's API method. It is like all the other handlers in the routine.

procedure TUSC.Log_In( User, Password : TSRB ; var IOSB : TIOSB ) ;

var Process : TProcess ;
    _User, _Password : string ;
    U : TUser ;

begin
    // Setup...
    IOSB.r_io_64.w_status := 0 ;
    Process := Get_Process( Kernel.PID ) ;
    if( Process.User <> nil ) then // User is logged in
    begin
        // This call is only valid for logged-out processes
        IOSB.r_io_64.w_status := UOSErr_Protection_Violation ;
        exit ;
    end ;

    // Get parameters...
    _User := Get_String( Kernel, Kernel.PID, User, IOSB.r_io_64.w_status ) ;
    if( IOSB.r_io_64.w_status <> 0 ) then
    begin
        exit ;
    end ;
    _Password := Get_String( Kernel, Kernel.PID, Password, IOSB.r_io_64.w_status ) ;
    if( IOSB.r_io_64.w_status <> 0 ) then
    begin
        exit ;
    end ;

This new method of the USC handles the log in process. First we get the process and check that there is no user associated with it. If there is, that means the user is already logged in and we exit with a Protection Violation exception. As mentioned above, this will not operate on a logged-in process. If it did, someone could write a brute-force program to try to get access to another account. Because of the requirement for the user to be logged out, no program other than LOGIN can call it - and then only if the process isn't yet logged in. Otherwise, we get the passed user name and password.

    // Validate user...
    U := Get_User( _User ) ;
    if( U = nil ) then // Not a valid user name
    begin
        IOSB.r_io_64.w_status := UOSErr_Record_Not_Found ;
        exit ;
    end ;

    // Authentication...
    // TODO

    // Log the user in...
    Process.This_User := U ;
    Process.Authorized_Privileges := U.Auth_Privileges ;
    Process.Current_Privileges := U.Privileges ;
end ; // TUSC.Log_In

Next we get the UAF record for the specified user. If not found, we exit with a Record Not Found error. Next we do authentication. However, you notice that that section of code is missing. The reason is that authentication is a big topic and I want to dedicate a full article (or two) to it in the future. For now, any attempt to log in will succeed if the specified user exists. Once past that, we set up the process.

function LOGIN( User, Pass : string ) : int64 ;

var SRB_U, SRB_P : TSRB ;

begin
    Set_String( User, SRB_U ) ;
    Set_String( Pass, SRB_P ) ;
    Result := SYS_LOGIN( int64( @SRB_U ), int64( @SRB_P ) ) ;
end ;

This simple Pascal interface to the system service is added to the PasStarlet unit.

Next we'll look at the SETDDIR service, called by LOGIN. This is the inverse of the GETDDIR service, covered in article 86. However, I neglected to include user documentation for SYS_GETDDIR, so we'll include them both here.

SYS_GETDDIR

Retrieves the default directory for a process.

Format

SYS_GETDDIR pid , result , len

Arguments

pid
An address pointing to a 64-bit integer containing the process ID. If 0 or if it points to a value of 0, the current process is used.

result
An address pointing to a buffer to receive the directory specification.

Len
An address pointing to a 64-bit integer value indicating the maximum size of the buffer specified by result. The actual size (not exceeding the specified maximum size) is written to this address.

Description

This service returns the default directory for the specified process. It can be changed with SYS_SETDDIR.

Condition Values Returned

SS_NORMAL Normal completion of service.
SS_NOPRIV The calling process does not have the privilege to get the default directory for the specified process.
SS_NONEXPR The specified process does not exist.

SYS_SETDDIR

Sets the default directory for a process.

Format

SYS_SETDDIR pid , value

Arguments

pid
An address pointing to a 64-bit integer containing the process ID of the process to modify.

value
A pointer to an SRB which points to a directory specification string.

Description

This service changes the default directory for the specific process. This value can be obtained with SYS_GETDDIR.

Condition Values Returned

SS_NORMAL Normal completion of service.
SS_NOPRIV The calling process does not have the privilege to change the default directory of the specified process.
SS_NONEXPR The specified process does not exist.

function SYS_SETDDIR( PID : TPID ; Name : TSRB ) : int64 ;

var SRB : PSRB ;
    Status : int64 ;
    SysRequest : TS1I1_Request ;

begin
    SRB := PSRB( pointer( @Name ) ) ;
    fillchar( SysRequest, sizeof( SysRequest ), 0 ) ;
    Status := 0 ;
    SysRequest.Request.Subsystem :=  UOS_Subsystem_USC ;
    SysRequest.Request.Request := UOS_USC_Set_Default_Directory ;
    SysRequest.Request.Length := sizeof( SysRequest ) - sizeof( Sysrequest.Request ) ;
    SysRequest.Request.Status := integer( @Status ) ;
    SysRequest.SRB.Buffer := SRB.Buffer ;
    SysRequest.SRB.Length := SRB.Length ;
    SysRequest.Integer1 := PID ;

    Call_To_Ring0( integer( @SysRequest ) ) ;

    Result := Status ;
end ;

This new routine in the SYS unit is the wrapper for the SYS_GETDDIR service.

        UOS_USC_Set_Default_Directory:
            begin
                UE := Enter_System_Call( Request, SReq, PID, MMC, sizeof( TS1I3_Request ) - sizeof( SReq ), 
                    Address ) ;
                if( UE <> nil ) then
                begin
                    Set_Last_Error( UE ) ;
                    exit ;
                end ;
                try
                    S1I1_Request := PS1I1_Request( Address ) ;
                    Set_Default_Directory( PID, S1I1_Request.SRB,
                        S1I3_Request.Integer1, IOSB ) ;
                    Write_User( Kernel, PID, S1I3_Request.Request.Status, sizeof( IOSB.r_io_64.w_status ), 
                        IOSB.r_io_64.w_status ) ;
                finally
                    Exit_System_Call( Request, PID, MMC, sizeof( TS1I3_Request ) - sizeof( SReq ) ) ;
                end ;
            end ;

This code is added to the USC's API method to respond to the SETDDIR call.

procedure TUSC.Set_Default_Directory( PID : TPID ; SRB : TSRB ;
    rPID : int64 ; var IOSB : TIOSB ) ;

var Process : TProcess ;
    S : string ;
    Status : integer ;
    US : TUOS_String ;

begin
    // Seutp...
    if( rPID = 0 ) then
    begin
        rPID := PID ;
    end ;
    Process := Get_Process( rPID ) ;
    if( Process = nil ) then
    begin
        IOSB.r_io_64.w_status := UE_Error ;
        Generate_Exception( UOSErr_Nonexistent_Process ) ;
        exit ;
    end ;

    US := Get_User_String( Kernel, PID, SRB, IOSB.r_io_64.w_status ) ;
    if( IOSB.r_io_64.w_status = UE_Error ) then
    begin
        if( US <> nil ) then
        begin
            US.Free ;
        end ;
        exit ;
    end ;
    S := As_UTF8( US ) ;
    US.Free ;
    Process.Default_Directory := S ;
end ; // TUSC.Set_Default_Directory

This new USC method obtains the process, exiting on error. It then obtains the process' default directory and writes it to the user's buffer.

procedure Set_Echo( Handle : integer ; Enable : boolean ) ;

var Buffer : IOSetMode_Buffer ;
    IOSB : TIOSB ;

begin
    SYS_QIOW( 0, RH_SysCommand, IO_SENSEMODE, int64( @iosb ), 0, 0, int64( @Buffer ), 0, 0, 0, 0, 0 ) ;
        // Get flags
    if( Enable ) then
    begin
        Buffer.Characteristics := Buffer.Characteristics and ( not TT_M_NOECHO ) ;
    end else
    begin
        Buffer.Characteristics := Buffer.Characteristics or TT_M_NOECHO ;
    end ;
    SYS_QIOW( 0, RH_SysCommand, IO_SETCHAR, int64( @iosb ), 0, 0, int64( @Buffer ), 0, 0, 0, 0, 0 ) ; 
        // Set flag
end ;

This new function in PasStarlet is used to turn echo on and off. Two articles ago we discussed a change to QIO to handle the IO_SETCHAR option. This source code gets the current terminal charateristics and either adds the TT_M_NOECHO flag, or removes it, depending upon the value of Enable. It then sets the terminal characteristics to this new value. All other characteristic flags are left alone.

In the next article, we will start to look at the system configuration script.