+++ /dev/null
-/*
- * auth.c - deal with authentication.
- *
- * This file implements the VNC authentication protocol when setting up an RFB
- * connection.
- */
-
-/*
- * Copyright (C) 2005 Rohit Kumar, Johannes E. Schindelin
- * OSXvnc Copyright (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.
- * Original Xvnc code Copyright (C) 1999 AT&T Laboratories Cambridge.
- * All Rights Reserved.
- *
- * This is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this software; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
- * USA.
- */
-
-#include <rfb/rfb.h>
-
-/* RFB 3.8 clients are well informed */
-void rfbClientSendString(rfbClientPtr cl, char *reason);
-
-
-/*
- * Handle security types
- */
-
-static rfbSecurityHandler* securityHandlers = NULL;
-
-/*
- * This method registers a list of new security types.
- * It avoids same security type getting registered multiple times.
- * The order is not preserved if multiple security types are
- * registered at one-go.
- */
-void
-rfbRegisterSecurityHandler(rfbSecurityHandler* handler)
-{
- rfbSecurityHandler *head = securityHandlers, *next = NULL;
-
- if(handler == NULL)
- return;
-
- next = handler->next;
-
- while(head != NULL) {
- if(head == handler) {
- rfbRegisterSecurityHandler(next);
- return;
- }
-
- head = head->next;
- }
-
- handler->next = securityHandlers;
- securityHandlers = handler;
-
- rfbRegisterSecurityHandler(next);
-}
-
-/*
- * This method unregisters a list of security types.
- * These security types won't be available for any new
- * client connection.
- */
-void
-rfbUnregisterSecurityHandler(rfbSecurityHandler* handler)
-{
- rfbSecurityHandler *cur = NULL, *pre = NULL;
-
- if(handler == NULL)
- return;
-
- if(securityHandlers == handler) {
- securityHandlers = securityHandlers->next;
- rfbUnregisterSecurityHandler(handler->next);
- return;
- }
-
- cur = pre = securityHandlers;
-
- while(cur) {
- if(cur == handler) {
- pre->next = cur->next;
- break;
- }
- pre = cur;
- cur = cur->next;
- }
- rfbUnregisterSecurityHandler(handler->next);
-}
-
-/*
- * Send the authentication challenge.
- */
-
-static void
-rfbVncAuthSendChallenge(rfbClientPtr cl)
-{
-
- /* 4 byte header is alreay sent. Which is rfbSecTypeVncAuth
- (same as rfbVncAuth). Just send the challenge. */
- rfbRandomBytes(cl->authChallenge);
- if (rfbWriteExact(cl, (char *)cl->authChallenge, CHALLENGESIZE) < 0) {
- rfbLogPerror("rfbAuthNewClient: write");
- rfbCloseClient(cl);
- return;
- }
-
- /* Dispatch client input to rfbVncAuthProcessResponse. */
- cl->state = RFB_AUTHENTICATION;
-}
-
-/*
- * Send the NO AUTHENTICATION. SCARR
- */
-
-static void
-rfbVncAuthNone(rfbClientPtr cl)
-{
- uint32_t authResult;
-
- if (cl->protocolMajorVersion==3 && cl->protocolMinorVersion > 7) {
- rfbLog("rfbProcessClientSecurityType: returning securityResult for client rfb version >= 3.8\n");
- authResult = Swap32IfLE(rfbVncAuthOK);
- if (rfbWriteExact(cl, (char *)&authResult, 4) < 0) {
- rfbLogPerror("rfbAuthProcessClientMessage: write");
- rfbCloseClient(cl);
- return;
- }
- }
- cl->state = RFB_INITIALISATION;
- return;
-}
-
-
-/*
- * Advertise the supported security types (protocol 3.7). Here before sending
- * the list of security types to the client one more security type is added
- * to the list if primaryType is not set to rfbSecTypeInvalid. This security
- * type is the standard vnc security type which does the vnc authentication
- * or it will be security type for no authentication.
- * Different security types will be added by applications using this library.
- */
-
-static rfbSecurityHandler VncSecurityHandlerVncAuth = {
- rfbSecTypeVncAuth,
- rfbVncAuthSendChallenge,
- NULL
-};
-
-static rfbSecurityHandler VncSecurityHandlerNone = {
- rfbSecTypeNone,
- rfbVncAuthNone,
- NULL
-};
-
-
-static void
-rfbSendSecurityTypeList(rfbClientPtr cl, int primaryType)
-{
- /* The size of the message is the count of security types +1,
- * since the first byte is the number of types. */
- int size = 1;
- rfbSecurityHandler* handler;
-#define MAX_SECURITY_TYPES 255
- uint8_t buffer[MAX_SECURITY_TYPES+1];
-
-
- /* Fill in the list of security types in the client structure. (NOTE: Not really in the client structure) */
- switch (primaryType) {
- case rfbSecTypeNone:
- rfbRegisterSecurityHandler(&VncSecurityHandlerNone);
- break;
- case rfbSecTypeVncAuth:
- rfbRegisterSecurityHandler(&VncSecurityHandlerVncAuth);
- break;
- }
-
- for (handler = securityHandlers;
- handler && size<MAX_SECURITY_TYPES; handler = handler->next) {
- buffer[size] = handler->type;
- size++;
- }
- buffer[0] = (unsigned char)size-1;
-
- /* Send the list. */
- if (rfbWriteExact(cl, (char *)buffer, size) < 0) {
- rfbLogPerror("rfbSendSecurityTypeList: write");
- rfbCloseClient(cl);
- return;
- }
-
- /*
- * if count is 0, we need to send the reason and close the connection.
- */
- if(size <= 1) {
- /* This means total count is Zero and so reason msg should be sent */
- /* The execution should never reach here */
- char* reason = "No authentication mode is registered!";
-
- rfbClientSendString(cl, reason);
- return;
- }
-
- /* Dispatch client input to rfbProcessClientSecurityType. */
- cl->state = RFB_SECURITY_TYPE;
-}
-
-
-
-
-/*
- * Tell the client what security type will be used (protocol 3.3).
- */
-static void
-rfbSendSecurityType(rfbClientPtr cl, int32_t securityType)
-{
- uint32_t value32;
-
- /* Send the value. */
- value32 = Swap32IfLE(securityType);
- if (rfbWriteExact(cl, (char *)&value32, 4) < 0) {
- rfbLogPerror("rfbSendSecurityType: write");
- rfbCloseClient(cl);
- return;
- }
-
- /* Decide what to do next. */
- switch (securityType) {
- case rfbSecTypeNone:
- /* Dispatch client input to rfbProcessClientInitMessage. */
- cl->state = RFB_INITIALISATION;
- break;
- case rfbSecTypeVncAuth:
- /* Begin the standard VNC authentication procedure. */
- rfbVncAuthSendChallenge(cl);
- break;
- default:
- /* Impossible case (hopefully). */
- rfbLogPerror("rfbSendSecurityType: assertion failed");
- rfbCloseClient(cl);
- }
-}
-
-
-
-/*
- * rfbAuthNewClient is called right after negotiating the protocol
- * version. Depending on the protocol version, we send either a code
- * for authentication scheme to be used (protocol 3.3), or a list of
- * possible "security types" (protocol 3.7).
- */
-
-void
-rfbAuthNewClient(rfbClientPtr cl)
-{
- int32_t securityType = rfbSecTypeInvalid;
-
- if (!cl->screen->authPasswdData || cl->reverseConnection) {
- /* chk if this condition is valid or not. */
- securityType = rfbSecTypeNone;
- } else if (cl->screen->authPasswdData) {
- securityType = rfbSecTypeVncAuth;
- }
-
- if (cl->protocolMajorVersion==3 && cl->protocolMinorVersion < 7)
- {
- /* Make sure we use only RFB 3.3 compatible security types. */
- if (securityType == rfbSecTypeInvalid) {
- rfbLog("VNC authentication disabled - RFB 3.3 client rejected\n");
- rfbClientConnFailed(cl, "Your viewer cannot handle required "
- "authentication methods");
- return;
- }
- rfbSendSecurityType(cl, securityType);
- } else {
- /* Here it's ok when securityType is set to rfbSecTypeInvalid. */
- rfbSendSecurityTypeList(cl, securityType);
- }
-}
-
-/*
- * Read the security type chosen by the client (protocol 3.7).
- */
-
-void
-rfbProcessClientSecurityType(rfbClientPtr cl)
-{
- int n;
- uint8_t chosenType;
- rfbSecurityHandler* handler;
-
- /* Read the security type. */
- n = rfbReadExact(cl, (char *)&chosenType, 1);
- if (n <= 0) {
- if (n == 0)
- rfbLog("rfbProcessClientSecurityType: client gone\n");
- else
- rfbLogPerror("rfbProcessClientSecurityType: read");
- rfbCloseClient(cl);
- return;
- }
-
- /* Make sure it was present in the list sent by the server. */
- for (handler = securityHandlers; handler; handler = handler->next) {
- if (chosenType == handler->type) {
- rfbLog("rfbProcessClientSecurityType: executing handler for type %d\n", chosenType);
- handler->handler(cl);
- return;
- }
- }
-
- rfbLog("rfbProcessClientSecurityType: wrong security type (%d) requested\n", chosenType);
- rfbCloseClient(cl);
-}
-
-
-
-/*
- * rfbAuthProcessClientMessage is called when the client sends its
- * authentication response.
- */
-
-void
-rfbAuthProcessClientMessage(rfbClientPtr cl)
-{
- int n;
- uint8_t response[CHALLENGESIZE];
- uint32_t authResult;
-
- if ((n = rfbReadExact(cl, (char *)response, CHALLENGESIZE)) <= 0) {
- if (n != 0)
- rfbLogPerror("rfbAuthProcessClientMessage: read");
- rfbCloseClient(cl);
- return;
- }
-
- if(!cl->screen->passwordCheck(cl,(const char*)response,CHALLENGESIZE)) {
- rfbErr("rfbAuthProcessClientMessage: password check failed\n");
- authResult = Swap32IfLE(rfbVncAuthFailed);
- if (rfbWriteExact(cl, (char *)&authResult, 4) < 0) {
- rfbLogPerror("rfbAuthProcessClientMessage: write");
- }
- /* support RFB 3.8 clients, they expect a reason *why* it was disconnected */
- if (cl->protocolMinorVersion > 7) {
- rfbClientSendString(cl, "password check failed!");
- }
- else
- rfbCloseClient(cl);
- return;
- }
-
- authResult = Swap32IfLE(rfbVncAuthOK);
-
- if (rfbWriteExact(cl, (char *)&authResult, 4) < 0) {
- rfbLogPerror("rfbAuthProcessClientMessage: write");
- rfbCloseClient(cl);
- return;
- }
-
- cl->state = RFB_INITIALISATION;
-}
projects / presencevnc / blobdiff