RE: [Cdsa-discuss] Challenge callbacks.

[Wood, M. D <mat...@in...>]

Your are correct in stating that CDSA does not support two-or-more-stage
authentication via means other than challenge callbacks. There is no
technical reason I can think of why either method is necessarily better. It
was a just design decision made early in CDSAs development.

Offering samples as part of the access credentials is no less secure than
any other software crypto interface. I'll use CSP authentication for a
couple examples.

In the case of password based authentication, the application can do one of
two things:

1) Query the key ACL and get the appropriate password before making the
crypto call
2) Pass a callback and let the CSP decide if and when it asks the app to get
a password

The first option is the same sequence you would use with other APIs. The
second option gives the app the flexibility of not keeping passwords in
memory if it doesn't want to. It just waits for the CSP to ask, gets it and
returns it. No need to store it for any period of time.

For nonce signing, there is no difference in security because there is no
sample. Callbacks are required to allow the caller to sign the nonce.

Checking the caller's return address to make sure that it's the same module
getting a challenge as the one using it would be a valid added vigilance
tactic if the two-stage authentication model was supported, but it could get
complicated. CDSA modules receive all of their calls from the same module,
the CSSM. To make it work the module would have to go around the CSSM and
validate the caller. The modules don't currently do this because they trust
the CSSM to do this for them. It would look around the CSSM by referencing
the handle used to make the calls and obtain its identification information.
Add in the fact that sometimes the app passes a module handle to another
module's API (most of TP, some CL APIs). In those cases the caller using the
handle isn't even the one that performed the attach! My head is hurting
already. With this in mind, lets look at the simple case of having a CL sign
a certificate as an example. In this case, the app is calling the CL and the
CL calls the CSP. Using two-stage authentication, the application would
probably fetch the challenge, sign it, and pass the nonce signature to the
CL as authentication credentials to the cert sign API. The return address
check would fail in this case because different modules are making the
calls.

Hope this helps,
Matt

> -----Original Message-----
> From: Chris Quinn [mailto:cq...@ht...]
> Sent: Thursday, September 27, 2001 10:37 AM
> To: cdsa
> Subject: [Cdsa-discuss] Challenge callbacks.
> 
> 
> Hi list,
> 
> I'm making a language binding for CDSA and found handling 
> challenge callbacks not to be straightforward.
> I don't see any security problem having a challenge a two 
> step process handled from a single thread:
>  1) request challenge in relation to a particular operation
>  2) do whatever is necessary with the challenge and make
>     another call offering a response
> 
> As long as CDSA can verify validity of callers address (as it 
> does anyway) and can tie the response to the initial request, 
> there should be no problem.
> 
> Firstly, is this really a valid way to do things?
> Secondly, does CDSA provide for it?
> 
> Although I am as yet unfamiliar with sorts of challenges 
> other than nonce signing, it seems to me offering samples as 
> part of the access credentials has to be a lower security option.
> 
> If that is true, and CDSA does not provide a two-stage mode 
> (either because it is meaningless to do so or simply designed 
> that way), will I have any option than to thrash out a 
> callback scheme?
> 
> Thanks,
> Chris 
> 
> Thanks,
> Chris Q.
> -- 
> Chris Quinn
> 
> _______________________________________________
> Cdsa-discuss mailing list
> Cds...@li...
> https://lists.sourceforge.net/lists/listinfo/cdsa-discuss
>