Exemplo n.º 1
0
void RfbInitializer::initAuthenticate()
{
  try {
    // Determine effective security type from the configuration.
    UINT32 primSecType = SecurityDefs::VNC;
    if (!Configurator::getInstance()->getServerConfig()->isUsingAuthentication()
        || !m_authAllowed) {
      primSecType = SecurityDefs::NONE;
    }
    // Here the protocol varies between versions 3.3 and 3.7+.
    if (m_minorVerNum >= 7) {
      // Send a list with two security types -- VNC-compatible security type
      // and a special code allowing to enable TightVNC protocol extensions.
      m_output->writeUInt8(2);
      m_output->writeUInt8(primSecType);
      m_output->writeUInt8(SecurityDefs::TIGHT);
      // Read what the client has actually selected.
      UINT8 clientSecType = m_input->readUInt8();
      if (clientSecType == SecurityDefs::TIGHT) {
        m_tightEnabled = true;
        doTightAuth();
      } else {
        if (clientSecType != primSecType) {
          throw Exception(_T("Security types do not match"));
        }
        doAuth(AuthDefs::convertFromSecurityType(clientSecType));
      }
    } else {
      // Just tell the client we will use the configured security type.
      m_output->writeUInt32(primSecType);
      doAuth(AuthDefs::convertFromSecurityType(primSecType));
    }
  } catch (AuthException &e) {
    // FIXME: The authentication result must be sent in protocols 3.3 and 3.7
    //        as well, unless the authentication was set to AuthDefs::NONE.
    if (m_minorVerNum >= 8) {
      AnsiStringStorage reason(&StringStorage(e.getMessage()));
      unsigned int reasonLen = (unsigned int)reason.getLength();
      _ASSERT(reasonLen == reason.getLength());

      m_output->writeUInt32(1); // FIXME: Use a named constant instead of 1.
      m_output->writeUInt32(reasonLen);
      m_output->writeFully(reason.getString(), reasonLen);
    }
    throw;
  }
}
Exemplo n.º 2
0
void RfbInitializer::initAuthenticate()
{
  try {
    UINT32 primSecType = SecurityDefs::VNC;
    if (!Configurator::getInstance()->getServerConfig()->isUsingAuthentication()
        || !m_authAllowed) {
      primSecType = SecurityDefs::NONE;
    }
    if (m_minorVerNum >= 7) {
      m_output->writeUInt8(2);
      m_output->writeUInt8(primSecType);
      m_output->writeUInt8(SecurityDefs::TIGHT);
      UINT8 clientSecType = m_input->readUInt8();
      if (clientSecType == SecurityDefs::TIGHT) {
        m_tightEnabled = true;
        doTightAuth();
      } else {
        if (clientSecType != primSecType) {
          throw Exception(_T("Security types do not match"));
        }
        doAuth(AuthDefs::convertFromSecurityType(clientSecType));
      }
    } else {
      m_output->writeUInt32(primSecType);
      doAuth(AuthDefs::convertFromSecurityType(primSecType));
    }
  } catch (AuthException &e) {
    if (m_minorVerNum >= 8) {
      StringStorage errorMessage(e.getMessage());
      size_t reasonLen = errorMessage.getLength();
      char *reason = new char[reasonLen + 1];
      try {
        if (errorMessage.toAnsiString(reason, reasonLen + 1)) {
          m_output->writeUInt32(1); 
          m_output->writeUInt32(reasonLen);
          m_output->writeFully(reason, reasonLen);
        }
      } catch (...) {
        delete reason;
        throw;
      }
      delete reason;
    }
    throw;
  }
}
Exemplo n.º 3
0
void RfbInitializer::doTightAuth()
{
  m_output->writeUInt32(0);
  if (Configurator::getInstance()->getServerConfig()->isUsingAuthentication()
      && m_authAllowed) {
    CapContainer authInfo;
    authInfo.addCap(AuthDefs::VNC, VendorDefs::STANDARD, AuthDefs::SIG_VNC);
    m_output->writeUInt32(authInfo.getCapCount());
    authInfo.sendCaps(m_output);
    UINT32 clientAuthValue = m_input->readUInt32();
    if (!authInfo.includes(clientAuthValue)) {
      throw Exception(_T(""));
    }
    doAuth(clientAuthValue);
  } else {
    m_output->writeUInt32(0);
    doAuth(AuthDefs::NONE);
  }
}
Exemplo n.º 4
0
void QAuthApp::setUp() {
    QStringList args = QCoreApplication::arguments();
    QString server;
    int pos;

    if ((pos = args.indexOf("--socket")) >= 0) {
        if (pos >= args.length() - 1) {
            qCritical() << "This application is not supposed to be executed manually";
            exit(OTHER_ERROR);
            return;
        }
        server = args[pos + 1];
    }

    if ((pos = args.indexOf("--id")) >= 0) {
        if (pos >= args.length() - 1) {
            qCritical() << "This application is not supposed to be executed manually";
            exit(OTHER_ERROR);
            return;
        }
        m_id = QString(args[pos + 1]).toLongLong();
    }

    if ((pos = args.indexOf("--start")) >= 0) {
        if (pos >= args.length() - 1) {
            qCritical() << "This application is not supposed to be executed manually";
            exit(OTHER_ERROR);
            return;
        }
        m_session->setPath(args[pos + 1]);
    }

    if ((pos = args.indexOf("--user")) >= 0) {
        if (pos >= args.length() - 1) {
            qCritical() << "This application is not supposed to be executed manually";
            exit(OTHER_ERROR);
            return;
        }
        m_user = args[pos + 1];
    }

    if ((pos = args.indexOf("--autologin")) >= 0) {
        m_backend->setAutologin(true);
    }

    if (server.isEmpty() || m_id <= 0) {
        qCritical() << "This application is not supposed to be executed manually";
        exit(OTHER_ERROR);
        return;
    }

    connect(m_socket, SIGNAL(connected()), this, SLOT(doAuth()));
    connect(m_session, SIGNAL(finished(int)), this, SLOT(sessionFinished(int)));
    m_socket->connectToServer(server, QIODevice::ReadWrite | QIODevice::Unbuffered);
}
Exemplo n.º 5
0
void RfbInitializer::doTightAuth()
{
  // Negotiate tunneling.
  m_output->writeUInt32(0);
  // Negotiate authentication.
  // FIXME: Recognize authentication types.
  if (Configurator::getInstance()->getServerConfig()->isUsingAuthentication()
      && m_authAllowed) {
    CapContainer authInfo;
    authInfo.addCap(AuthDefs::VNC, VendorDefs::STANDARD, AuthDefs::SIG_VNC);
    m_output->writeUInt32(authInfo.getCapCount());
    authInfo.sendCaps(m_output);
    // Read the security type selected by the client.
    UINT32 clientAuthValue = m_input->readUInt32();
    if (!authInfo.includes(clientAuthValue)) {
      throw Exception(_T(""));
    }
    doAuth(clientAuthValue);
  } else {
    m_output->writeUInt32(0);
    doAuth(AuthDefs::NONE);
  }
}
bool Connection::createConnection()
{
    bool rval = false;
    struct sockaddr_in remote = {};

    remote.sin_port = htons(m_port);
    remote.sin_family = AF_INET;

    if (inet_aton(m_address.c_str(), (struct in_addr*)&remote.sin_addr.s_addr) == 0)
    {
        m_error = "Invalid address: ";
        m_error += m_address;
    }
    else
    {
        int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

        if (fd == -1)
        {
            char err[ERRBUF_SIZE];
            m_error = "Failed to create socket: ";
            m_error += strerror_r(errno, err, sizeof (err));
        }

        m_fd = fd;

        if (connect(fd, (struct sockaddr*) &remote, sizeof (remote)) == -1)
        {
            char err[ERRBUF_SIZE];
            m_error = "Failed to connect: ";
            m_error += strerror_r(errno, err, sizeof (err));
        }
        else if (doAuth())
        {
            rval = doRegistration();
        }
    }

    return rval;
}
Exemplo n.º 7
0
void Router::onMessage(Connection *conn)
{
	Buffer *pBuffer = conn->getBuffer();
	while(true)
	{
		if(pBuffer->size() < ROUTER_HEAD_SIZE){
			return ;
		}
		
		RouterMsg msg = unpackMsg(pBuffer->data());
		if(pBuffer->size() < ROUTER_HEAD_SIZE + msg.slen + msg.len){
			return ;
		}
		
		RouterMsg *pMsg = (RouterMsg*)pBuffer->data();
		pMsg->type = msg.type;
		pMsg->slen = msg.slen;
		pMsg->len = msg.len;
		LOG("on data, type=%d, slen=%d, len=%d", pMsg->type, pMsg->slen, pMsg->len);
		
		switch(pMsg->type){
			case ROUTER_MSG_AUTH:
				doAuth(conn, pMsg);
				break;
			case ROUTER_MSG_CONN:
				doConn(conn, pMsg);
				break;
			case ROUTER_MSG_CLOSE:
				doClose(conn, pMsg);
				break;
			case ROUTER_MSG_KICK:
				doKick(conn, pMsg);
				break;
			case ROUTER_MSG_SEND_MSG:
				doSendMsg(conn, pMsg);
				break;
			case ROUTER_MSG_SEND_ALL:
				doSendAllMsg(conn, pMsg);
				break;
			case ROUTER_MSG_CH_ADD:
				doChannelAdd(conn, pMsg);
				break;
			case ROUTER_MSG_CH_DEL:
				doChannelDel(conn, pMsg);
				break;
			case ROUTER_MSG_CH_PUB:
				doChannelPub(conn, pMsg);
				break;
			case ROUTER_MSG_CH_SUB:
				doChannelSub(conn, pMsg);
				break;
			case ROUTER_MSG_CH_UNSUB:
				doChannelUnSub(conn, pMsg);
				break;
			case ROUTER_MSG_INFO:
				doInfo(conn, pMsg);
				break;
			default:
				LOG("[router]error type");
				break;
		}
		
		pBuffer->seek(ROUTER_HEAD_SIZE + pMsg->slen + pMsg->len);
	}
}