Ok, now finally found a solution to solve this. I just post my approach so that everyone who has got the same problem can take this in consideration. ;)

I took a look at the initialization of my projection matrix. There i defined the field of view in angle, to be precisely it was PI/4 = 0.7853... defined by XM_PIDIV4:

XMMATRIX projMatrix = XMMatrixPerspectiveFovLH(XM_PIDIV4, (float)(screenWidth) / (float)(screenHeight), 0.01f, 100.0f);

As far as I have understood the perspective projection this value defines the field of view in radian angle in horizontal and vertical direction. So everytime I rotate my camera the field of view is streched around my lookTo vector by the angle XM_PIDIV4 in radian. Therefore my lookTo vector intersects with the center of every plane wich lies in the frustum and is parallel to the view plane.

With those information I did the following:

I took my up and right vector of my view space and generated rotation matrices which rotate around each of them with the angle XM_PIDV/2.0, just the half of my field of view:

XMMATRIX rotY = XMMatrixRotationAxis(up, XM_PIDIV4/1.3);
XMMATRIX rotX = XMMatrixRotationAxis(right, XM_PIDIV4/2.);
XMMATRIX rot_Y = XMMatrixRotationAxis(up, -XM_PIDIV4/1.3); //other direction
XMMATRIX rot_X = XMMatrixRotationAxis(right, -XM_PIDIV4/2.); //other direction

With those rotation matrices I took my lookTo vector and rotated him in such a way that I get all the four vectors which define the corners of my frustum:

XMVECTOR topleft, topright, bottomleft, bottomright;
topright = XMVector3Transform(lookTo, rotY);
topright = XMVector3Transform(topright, rot_X);
topleft = XMVector3Transform(lookTo, rot_Y);
topleft = XMVector3Transform(topleft, rot_X);
bottomright = XMVector3Transform(lookTo, rotY);
bottomright = XMVector3Transform(bottomright, rotX);
bottomleft = XMVector3Transform(lookTo, rot_Y);
bottomleft = XMVector3Transform(bottomleft, rotX);

Now it was possible to travel down on those vectors to get to the new corners of the plane which is parallel to the view plane. I used the mouse wheel to define the distance between both planes:

topright *= mouseZabsolute;
topleft *= mouseZabsolute;
bottomright *= mouseZabsolute;
bottomleft *= mouseZabsolute;

I haven't normalized the different vectors before, because my lookTo vector was already normalized.

In the next step I defined the right and up vector of the plane, so that their magnitudes are the width and height of the plane:

right = topleft - topright;
up = topleft - bottomleft;

Then I normalized the mouse coordinates which are in screen space

float normMouseX = (float)(-mouseXabsolute)/((float)(_screenWidth));
float normMouseY = (float)(-mouseYabsolute)/((float)(_screenHeight));

and used them to move my cursor on that plane:

cursor += camPos + topleft+normMouseX*right+normMouseY*up;

There is still one thing which bothers me. The rotation around the up vector must be adjusted everytime the aspect ratio changes. I found out that when the aspect ratio is 1.333 the somehow optimal rotation angle in radian is XM_PIDIV4/1.7 and when the aspect ratio is 1.777 the angle is XM_PIDIV4/1.3 . I can't figure out for now how to adjust this divisor properly.