Ejemplo n.º 1
0
void	DoAdminUserCreate()
{
  u_int32_t	status = SSH2_FX_FAILURE;
  char		*args[5];
  char		*userName;
  char		*passWord;
  char		*homePath;
  int		ret;

  userName = BufferGetString(bIn);
  passWord = BufferGetString(bIn);
  homePath = BufferGetString(bIn);
  args[0] = MSS_SFTPUSER;
  args[1] = "create";
  args[2] = userName;
  args[3] = homePath;
  args[4] = NULL;
  (void )ExecCommandWithArgs(args, &ret, passWord, 0);
  if (ret == 0)
    {
      args[1] = "hide";
      args[3] = "0";
      (void )ExecCommandWithArgs(args, &ret, NULL, 0);
      status = SSH2_FX_OK;
    }
  DEBUG((MYLOG_DEBUG, "[DoAdminUserCreate]User:%s Home:%s Pass:%s status:%i", userName, homePath, passWord, status));
  SendStatus(bOut, 0, status);
  free(userName);
  free(passWord);
  free(homePath);
}
Ejemplo n.º 2
0
void DoExtDiskSpace(tBuffer *bIn, tBuffer *bOut, u_int32_t id)
{
	struct STATFS stfs;
	tFSPath	*realPath;
	char *path;

	path = convertFromUtf8(BufferGetString(bIn), 1);
	realPath = FSCheckPath(path);
	DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH]Path: %s", path));
	if (realPath != NULL && !HAS_BIT(gl_var->flagsDisable, SFTP_DISABLE_STATSFS))
	{
		DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH]Realpath: %s", realPath->realPath));
		if (STATFS(realPath->realPath, &stfs) == 0)
		{
			tBuffer *b;

			b = BufferNew();
			BufferPutInt8(b, SSH2_FXP_EXTENDED_REPLY);
			BufferPutInt32(b, id);
			BufferPutInt64(b, (u_int64_t) stfs.f_blocks * (u_int64_t) stfs.f_bsize);
			BufferPutInt64(b, (u_int64_t) stfs.f_bfree * (u_int64_t) stfs.f_bsize);
			BufferPutInt64(b, 0);
			BufferPutInt64(b, (u_int64_t) stfs.f_bavail * (u_int64_t) stfs.f_bsize);
			BufferPutInt32(b, stfs.f_bsize);
			BufferPutPacket(bOut, b);
		}
		else
			SendStatus(bOut, id, errnoToPortable(errno));
	}
	else
		SendStatus(bOut, id, SSH2_FX_PERMISSION_DENIED);
	FSDestroyPath(realPath);
	free(path);
}
Ejemplo n.º 3
0
void DoExtDiskSpaceOpenSSH_Name(tBuffer *bIn, tBuffer *bOut, u_int32_t id)
{
	char *path;

	path = BufferGetString(bIn);
	DoExtDiskSpaceOpenSSH_Path(bOut, id, path);
	free(path);
}
Ejemplo n.º 4
0
JNIEXPORT jstring JNICALL Java_com_aio4c_buffer_Buffer_getString(JNIEnv* jvm, jobject buffer) {
    Buffer* _buffer = _GetBuffer(jvm, buffer);
    char* str = NULL;
    jstring _string = NULL;

    BufferGetString(_buffer, &str);

    _string = (*jvm)->NewStringUTF(jvm, str);

    return _string;
}
Ejemplo n.º 5
0
void DoExtHardLink(tBuffer *bIn, tBuffer *bOut, u_int32_t id)
{
	char *link, *target;
	int status = SSH2_FX_OK;

	link = convertFromUtf8(BufferGetString(bIn), 1);
	target = convertFromUtf8(BufferGetString(bIn), 1);
	if (HAS_BIT(gl_var->flagsDisable, SFTP_DISABLE_SYMLINK))
	{
		DEBUG((MYLOG_DEBUG, "[DoExtHardLink]Disabled by conf."));
		status = SSH2_FX_PERMISSION_DENIED;
	}
	else
	{
		status = FSHardlink(target, link);
		DEBUG((MYLOG_DEBUG, "[DoExtHardLink]link:'%s' target:'%s' -> %i", link, target, status));
	}
	SendStatus(bOut, id, status);
	free(target);
	free(link);
}
Ejemplo n.º 6
0
void DoExtFileHashing_Name(tBuffer *bIn, tBuffer *bOut, u_int32_t id)
{
	char *file = BufferGetString(bIn);
	int status, fd;

	status = FSOpenFile(file, &fd, O_RDONLY, 0, NULL);
	DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_Name]File: %s Status: %i", file, status));
	if (status == SSH2_FX_OK)
	{
		DoExtFileHashing_FD(bIn, bOut, id, fd);
		xclose(fd);
	}
	else
		SendStatus(bOut, id, status);
	free(file);
}
Ejemplo n.º 7
0
void	DoAdminUserDelete()
{
  u_int32_t	status = SSH2_FX_FAILURE;
  char		*args[5];
  char		*userName;
  int		ret;

  userName = BufferGetString(bIn);
  args[0] = MSS_SFTPUSER;
  args[1] = "delete";
  args[2] = userName;
  args[3] = "0";
  args[4] = NULL;
  (void )ExecCommandWithArgs(args, &ret, NULL, 0);
  if (ret == 0)
    status = SSH2_FX_OK;
  DEBUG((MYLOG_DEBUG, "[DoAdminUserDelete]User:%s status:%i", userName, status));
  SendStatus(bOut, 0, status);
  free(userName);
}
Ejemplo n.º 8
0
static void DoExtFileHashing_FD(tBuffer *bIn, tBuffer *bOut, u_int32_t id, int fd)
{
	gnutls_digest_algorithm_t gnuTlsAlgo = GNUTLS_DIG_UNKNOWN;
	u_int64_t offset, length;
	u_int32_t blockSize;
	char *algo;
	algo = BufferGetString(bIn);
	offset = BufferGetInt64(bIn);
	length = BufferGetInt64(bIn);
	blockSize = BufferGetInt32(bIn);
	if (lseek(fd, offset, SEEK_SET) == -1)
	{
		SendStatus(bOut, id, errnoToPortable(errno));
		DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]Error lseek1"));
		goto endOfFileHashing;
	}
	if (length == 0)//read the file to the end
	{
		u_int64_t endOfFile;

		if ((endOfFile = lseek(fd, 0, SEEK_END)) == -1)
		{
			SendStatus(bOut, id, errnoToPortable(errno));
			DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]Error lseek2"));
			goto endOfFileHashing;
		}
		length = endOfFile - offset;
		if (lseek(fd, offset, SEEK_SET) == -1)
		{
			SendStatus(bOut, id, errnoToPortable(errno));
			DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]Error lseek3"));
			goto endOfFileHashing;
		}
	}
	if (blockSize == 0)//read length in one time
		blockSize = length;
	DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]Algo:%s Fd:%i Offset:%llu Length:%llu BlockSize:%i",
					algo, fd, offset, length, blockSize));
	if (strcasecmp("md2", algo) == 0)
		gnuTlsAlgo = GNUTLS_DIG_MD2;
	else if (strcasecmp("md5", algo) == 0)
		gnuTlsAlgo = GNUTLS_DIG_MD5;
	else if (strcasecmp("sha1", algo) == 0)
		gnuTlsAlgo = GNUTLS_DIG_SHA1;
	else if (strcasecmp("sha224", algo) == 0)
		gnuTlsAlgo = GNUTLS_DIG_SHA224;
	else if (strcasecmp("sha256", algo) == 0)
		gnuTlsAlgo = GNUTLS_DIG_SHA256;
	else if (strcasecmp("sha384", algo) == 0)
		gnuTlsAlgo = GNUTLS_DIG_SHA384;
	else if (strcasecmp("sha512", algo) == 0)
		gnuTlsAlgo = GNUTLS_DIG_SHA512;
	if (gnuTlsAlgo != GNUTLS_DIG_UNKNOWN)
	{
		gnutls_hash_hd_t dig;
		tBuffer *b;
		size_t keySize = gnutls_hash_get_len(gnuTlsAlgo);
		char *gnuKey;
		char data[SSH2_READ_HASH];
		int inError = 0;
		int gnulTlsError;

		b = BufferNew();
		BufferPutInt8FAST(b, SSH2_FXP_EXTENDED_REPLY);
		BufferPutInt32(b, id);
		BufferPutString(b, algo);
		gnuKey = calloc(1, keySize);
		if (gnuKey == NULL)
			goto endOfFileHashing;
		if ((gnulTlsError = gnutls_hash_init(&dig, gnuTlsAlgo)) == 0)
		{
			while (length > 0)
			{
				u_int32_t r, off, len;

				length = (length > (u_int64_t) blockSize) ? length - (u_int64_t) blockSize : 0;
				off = blockSize;
				len = sizeof(data);
				DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]Read:%i Rest:%llu", len, length));
				while ((r = read(fd, data, len)) > 0)
				{
					DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]Compute block (%u/%u %u)", len, r, off));
					if ((gnulTlsError = gnutls_hash(dig, data, r)) != 0)
					{
						DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]Error gnutls_hmac [error: %i]", gnulTlsError));
						inError = 1;
						break;
					}
					off -= r;
					if (off < sizeof(data))
						len = off;
					if (off == 0)
						break;
				}
			}
		}
		else
		{
			DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]Error gnutls_hash_init [keySize: %li] [error: %i]", keySize, gnulTlsError));
			inError = 1;
		}
		if (inError == 0)
		{
			DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]Compute key... [keySize: %li][keyPointer: %p]", keySize, gnuKey));
			gnutls_hash_deinit(dig, gnuKey);
			DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]Hash: %X%X%X ...", gnuKey[0], gnuKey[1], gnuKey[2]));
			BufferPutRawData(b, gnuKey, keySize);
			BufferPutPacket(bOut, b);
		}
		else
			SendStatus(bOut, id, SSH2_FX_FAILURE);
		BufferDelete(b);
		free(gnuKey);
	}
	else
	{
		DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]No algorithm: %s", algo));
		SendStatus(bOut, id, SSH2_FX_OP_UNSUPPORTED);
	}
	endOfFileHashing: DEBUG((MYLOG_DEBUG, "[DoExtFileHashing_FD]End"));
	free(algo);
}