Tripp Parks's WebLog : Networking - P2P

ICANN: Should they spread the power around?

tparks — Wed, 12 Oct 2005 07:44:10 GMT

Christian Huitema thinks we should move to a p2p system for DNS replacement. Who is he you ask?

Since I've known him, he has been a Architect at Microsoft and now is the Director for Wireless in Windows Networking. Before he came to Microsoft he was a member of the Internet Architecture Board (IAB) from 1991 to 1996, and its chair between April 1993 and July 1995. You can read more on him here.

Peer Eventing and you

tparks — Tue, 30 Aug 2005 17:02:00 GMT

Now that we are successfully able to enumerate a static snapshot of people online at a particular time, It would be useful to register for when one of the people near you came or went. The Peer Collaboration stack allows you to do this with its eventing system. (this is the same eventing system as used in PeerGraph and PeerGroup)

The first thing you need to do is register for the event you are interested in, this is accomplished with this api:

HRESULT WINAPI PeerRegisterEvent(
HANDLE hEvent,
DWORD cEventRegistration,
PPEER_EVENT_REGISTRATION pEventRegistrations,
HPEEREVENT* phPeerEvent
);
http://windowssdk.msdn.microsoft.com/library/en-us/P2PSDK/p2p/peerregisterevent.asp

Of interest, this api takes a NT event which to signal, an array of events that you may be interested in and returns a Peer Event Handle that is used to identify this registration.

HRESULT WINAPI PeerUnregisterEvent(
HPEEREVENT hPeerEvent
);

http://windowssdk.msdn.microsoft.com/library/en-us/P2PSDK/p2p/peerunregisterevent.asp

which tells the system you are no longer interested in being signaled when this event happens.

When the event that you passed in to PeerRegisterEvent is signaled informing you that there is data, you call

HRESULT WINAPI PeerGetEventData(
HPEEREVENT hPeerEvent,
PPEER_EVENT_DATA* ppEventData
);
http://windowssdk.msdn.microsoft.com/library/en-us/P2PSDK/p2p/peergeteventdata.asp

Which returns the data associated with the event.

In practice the code looks like this:

typedef struct thread_data_tag

{

HANDLE hEvent;

HANDLE hPeerEvent;

HANDLE hShutdown;

} THREAD_DATA, *PTHREAD_DATA;

HRESULT RegisterForEvents(

HANDLE hShutdown,

PHANDLE phWaitEvent

)

{

HRESULT hr=S_OK;

PTHREAD_DATA pThreadData;

PEER_EVENT_REGISTRATION eventReg;

eventReg.eventType = PEER_EVENT_ENDPOINT_NEAR_ME_CHANGED;

eventReg.pInstance = NULL;

pThreadData =(PTHREAD_DATA)HeapAlloc(GetProcessHeap(), 0, sizeof(THREAD_DATA));

if ( pThreadData == NULL )

{

return E_OUTOFMEMORY;

}

pThreadData->hShutdown = hShutdown;

pThreadData->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);;

if ( pThreadData->hEvent == NULL )

{

HeapFree(GetProcessHeap(),0,pThreadData);

return HRESULT_FROM_WIN32(GetLastError());

}

hr = PeerRegisterEvent(pThreadData->hEvent, 1, &eventReg, &pThreadData->hPeerEvent );

if ( SUCCEEDED(hr) )

{

*phWaitEvent = CreateThread(NULL,0,EventThread,(LPVOID)pThreadData,0,NULL);

if ( phWaitEvent == NULL )

{

hr=HRESULT_FROM_WIN32(GetLastError());

}

if ( FAILED(hr) )

{

HeapFree(GetProcessHeap(),0,pThreadData);

CloseHandle(pThreadData->hEvent);

}

return hr;

}

DWORD WINAPI EventThread(LPVOID lpWaitHandles)

{

PTHREAD_DATA pThreadData = (PTHREAD_DATA)lpWaitHandles;

PHANDLE phWaitHandles;

BOOL bShutdown = FALSE;

phWaitHandles = (PHANDLE)HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLE) * 2);

if ( phWaitHandles != NULL )

{

phWaitHandles[0] = pThreadData->hShutdown;

phWaitHandles[1] = pThreadData->hEvent;

while ( !bShutdown )

{

switch ( WaitForMultipleObjects(2,phWaitHandles,FALSE,INFINITE) )

{

case WAIT_OBJECT_0:

{

printf("Shutdown\n");

bShutdown=TRUE;

break;

}

break;

case WAIT_OBJECT_0 + 1:

{

ProcessEvent(pThreadData->hPeerEvent);

}

break;

}

CloseHandle(pThreadData->hEvent);

PeerUnregisterEvent(pThreadData->hPeerEvent);

HeapFree(GetProcessHeap(),0,lpWaitHandles);

return 0;

}

VOID ProcessEvent(HPEEREVENT hPeerEvent )

{

PEER_EVENT_DATA *pEventData = NULL;

HRESULT hr=S_OK;

while ( TRUE )

{

hr = PeerGetEventData(hPeerEvent, &pEventData);

if ( FAILED(hr) || hr == PEER_S_NO_EVENT_DATA )

{

return;

}

switch ( pEventData->eventType )

{

case PEER_EVENT_ENDPOINT_NEAR_ME_CHANGED:

{

printf("%S",

pEventData->endpointNearMeChangedData.pEndpointNearMe->pwzFriendlyName,

);

}

break;

default:

{

printf("Event not Implemented");

}

break;

}

PeerFreeData(pEventData);

}

int __cdecl main(int argc, __in_ecount(argc) char *argv[])

{

HANDLE hThread;

HANDLE hShutdown;

HRESULT hr=S_OK;

char buff[512];

hr = PeerCollabStartup(PEER_COLLAB_VERSION);

if (SUCCEEDED(hr))

{

hr = PeerCollabSignin(PEER_PRESENCE_NEAR_ME);

if (SUCCEEDED(hr))

{

hr=EnumeratePeopleNearMe();

}

hShutdown =CreateEvent(NULL, FALSE, FALSE, NULL);

if ( hShutdown != NULL )

{

if ( SUCCEEDED(RegisterForEvents(hShutdown,&hThread)) )

{

while ( TRUE )

{

Sleep(0);

hr = StringCchGetsA(buff, 512);

if ( FAILED(hr) )

{

printf("StringCchGets failure.\n");

continue;

}

if ( strncmp(buff + 1, "quit", strlen("quit")) == 0 )

{

break;

}

SetEvent(hShutdown);

WaitForSingleObject(hThread,INFINITE);

}

CloseHandle(hShutdown);

CloseHandle(hThread);

}

(void)PeerCollabShutdown();

}

return 0;

}

Sorry for the repost, I didnt publish this correctly

Getting Started with the Collaboration API's!

tparks — Tue, 30 Aug 2005 17:00:00 GMT

Guess what the first api you have to call is?

HRESULT WINAPI PeerCollabStartup(
WORD wVersionRequested
);

http://windowssdk.msdn.microsoft.com/library/default.asp?url=/library/en-us/P2PSDK/p2p/peercollabstartup.asp

It's our friend Mr. Startup!

The only version currently supported is 1.0 and it has to be called before any

PeerCollab* Api

Thankfully we define the version in the p2p.h file as

PEER_COLLAB_VERSION

Which is able to be passed in nicely!

Of course Mr. Startup would be lonely without Mr. Shutdown, so here he is.

HRESULT WINAPI PeerCollabShutdown(void);
http://windowssdk.msdn.microsoft.com/library/default.asp?url=/library/en-us/P2PSDK/p2p/peercollabshutdown.asp

Now, these don't make a particularly interesting application as they don’t apparently do anything:) So lets see the first API that actually does something!

HRESULT WINAPI PeerCollabSignIn(
PEER_COLLAB_SIGNIN_OPTIONS eSigninOptions
);

http://windowssdk.msdn.microsoft.com/library/en-us/P2PSDK/p2p/peercollabsignin.asp

This is the API that is used to sign in to the serverless presence system, it takes one option, the sign in options which determine which scope you sign into ( subnet vs Internet, or both) currently defined as:

PEER_PRESENCE_INTERNET

PEER_PRESENCE_NEAR_ME

PEER_PRESENCE_ALL

First, lets just start with "Near Me" which is classified as all people on the same network link

(all hosts on the same broadcast domain (ie behind a common router port) )

So far our simple console application should look something like this:

int __cdecl main(int argc, __in_ecount(argc) char *argv[])

{

HRESULT hr = S_OK;

hr = PeerCollabStartup(PEER_COLLAB_VERSION);

if (SUCCEEDED(hr))

{

hr = PeerCollabSignin(PEER_PRESENCE_NEAR_ME);

(void)PeerCollabShutdown();

}

return 0;

}

Which while nicely formatted does nothing particularly interesting except sign us into the application. Next time we will actually do something useful!

Peer Networking Security Model

tparks — Thu, 27 Jan 2005 10:42:00 GMT

Security for the Peer Networking platform is achieved through self signed x.509 certificates. This method of using self signed certificates eliminates the need of having a certificate authority issue a certificate to each user in a network. This eliminates the cost (both monetary and time) associated with acquiring a x.509 certificate from a commercial certificate authority, but it is not without its drawbacks. The main drawback to self-signed certificates are that they have weak identity, i.e. no one has vouched that the true owner of the certificate is who he claims to be (which is what you pay a commercial CA for, they vouch that the owner of the certificate is the person they claim to be). The same is true for all self signed methods such as PGP, verification of the identity of the certificate owner is up to you. However, once you trust that the certificate is valid, no other party can claim to be the owner of that certificate.

Since each user and group in the Peer Networking platform essentially acts as a certificate authority, chains of trust can be built allowing more advanced semantics such as group membership ( a group must only use its certificate to sign that of its members) and delegated authority ( a user/group can allow others to use its name by signing their certificates).

That is the basic view of how peer networking uses x.509 for security. If you want a more precise overview the Peer Networking whitepaper is for you! You can find it at http://www.microsoft.com/technet/prodtechnol/winxppro/deploy/p2pintro.mspx

More later!

Tripp

What is the Microsoft Peer Networking platform?

tparks — Thu, 23 Dec 2004 05:16:00 GMT

The Microsoft Peer Networking Platform consists of several pieces:

Graphing - This is an application layer multicast protocol. Think of a replicated database, records in this database can be enumerated,searched,added, modified and deleted. By default, there is no security built into the graphing layer, however, it has a pluggable SSP and pluggable record layer verification
Security- The security layer of the Peer Networking Platform consists of self signed x.509-like certificates(other certificates can also be imported). This provides strong authentication and encryption, when used in combination with a SSP.
PNRP - The Peer Networking Resolution Protcol is name resolution protocol, like DNS, that works without servers . Names can be resolved and enumerated. Names can be secured using the certificates provided by the security layer, and resolvers can be assured that the name that was found is indeed the one that owns the certificate that the name was based on.
Grouping- Grouping combines the three other pieces of the Peer Networking platform. It consists of Graphing with the custom SSP + record layer verification using PNRP for resolution. A group creates a self signed certificate and signs member certificates with that certificate. Group membership is controled with certificate chains.

More details coming later!