/* * The contents of this file are subject to the Mozilla Public * License Version 1.1 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or * implied. See the License for the specific language governing * rights and limitations under the License. * * The Original Code is the Netscape security libraries. * * The Initial Developer of the Original Code is Netscape * Communications Corporation. Portions created by Netscape are * Copyright (C) 1994-2000 Netscape Communications Corporation. All * Rights Reserved. * * Contributor(s): * * Alternatively, the contents of this file may be used under the * terms of the GNU General Public License Version 2 or later (the * "GPL"), in which case the provisions of the GPL are applicable * instead of those above. If you wish to allow use of your * version of this file only under the terms of the GPL and not to * allow others to use your version of this file under the MPL, * indicate your decision by deleting the provisions above and * replace them with the notice and other provisions required by * the GPL. If you do not delete the provisions above, a recipient * may use your version of this file under either the MPL or the * GPL. */ #ifdef DEBUG static const char CVS_ID[] = "@(#) $RCSfile: asn1.c,v $ $Revision: 1.2 $ $Date: 2001/11/08 00:14:34 $ $Name: FIREFOX_1_0_RELEASE $"; #endif /* DEBUG */ /* * asn1.c * * At this point in time, this file contains the NSS wrappers for * the old "SEC" ASN.1 encoder/decoder stuff. */ #ifndef ASN1M_H #include "asn1m.h" #endif /* ASN1M_H */ #include "plarena.h" #include "secasn1.h" /* * The pointer-tracking stuff */ #ifdef DEBUG extern const NSSError NSS_ERROR_INTERNAL_ERROR; static nssPointerTracker decoder_pointer_tracker; static PRStatus decoder_add_pointer ( const nssASN1Decoder *decoder ) { PRStatus rv; rv = nssPointerTracker_initialize(&decoder_pointer_tracker); if( PR_SUCCESS != rv ) { return rv; } rv = nssPointerTracker_add(&decoder_pointer_tracker, decoder); if( PR_SUCCESS != rv ) { NSSError e = NSS_GetError(); if( NSS_ERROR_NO_MEMORY != e ) { nss_SetError(NSS_ERROR_INTERNAL_ERROR); } return rv; } return PR_SUCCESS; } static PRStatus decoder_remove_pointer ( const nssASN1Decoder *decoder ) { PRStatus rv; rv = nssPointerTracker_remove(&decoder_pointer_tracker, decoder); if( PR_SUCCESS != rv ) { nss_SetError(NSS_ERROR_INTERNAL_ERROR); } return rv; } /* * nssASN1Decoder_verify * * This routine is only available in debug builds. * * If the specified pointer is a valid pointer to an nssASN1Decoder * object, this routine will return PR_SUCCESS. Otherwise, it will * put an error on the error stack and return PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1DECODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Decoder_verify ( nssASN1Decoder *decoder ) { PRStatus rv; rv = nssPointerTracker_initialize(&decoder_pointer_tracker); if( PR_SUCCESS != rv ) { return PR_FAILURE; } rv = nssPointerTracker_verify(&decoder_pointer_tracker, decoder); if( PR_SUCCESS != rv ) { nss_SetError(NSS_ERROR_INVALID_ASN1DECODER); return PR_FAILURE; } return PR_SUCCESS; } static nssPointerTracker encoder_pointer_tracker; static PRStatus encoder_add_pointer ( const nssASN1Encoder *encoder ) { PRStatus rv; rv = nssPointerTracker_initialize(&encoder_pointer_tracker); if( PR_SUCCESS != rv ) { return rv; } rv = nssPointerTracker_add(&encoder_pointer_tracker, encoder); if( PR_SUCCESS != rv ) { NSSError e = NSS_GetError(); if( NSS_ERROR_NO_MEMORY != e ) { nss_SetError(NSS_ERROR_INTERNAL_ERROR); } return rv; } return PR_SUCCESS; } static PRStatus encoder_remove_pointer ( const nssASN1Encoder *encoder ) { PRStatus rv; rv = nssPointerTracker_remove(&encoder_pointer_tracker, encoder); if( PR_SUCCESS != rv ) { nss_SetError(NSS_ERROR_INTERNAL_ERROR); } return rv; } /* * nssASN1Encoder_verify * * This routine is only available in debug builds. * * If the specified pointer is a valid pointer to an nssASN1Encoder * object, this routine will return PR_SUCCESS. Otherwise, it will * put an error on the error stack and return PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1ENCODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Encoder_verify ( nssASN1Encoder *encoder ) { PRStatus rv; rv = nssPointerTracker_initialize(&encoder_pointer_tracker); if( PR_SUCCESS != rv ) { return PR_FAILURE; } rv = nssPointerTracker_verify(&encoder_pointer_tracker, encoder); if( PR_SUCCESS != rv ) { nss_SetError(NSS_ERROR_INVALID_ASN1ENCODER); return PR_FAILURE; } return PR_SUCCESS; } #endif /* DEBUG */ /* * nssASN1Decoder_Create * * This routine creates an ASN.1 Decoder, which will use the specified * template to decode a datastream into the specified destination * structure. If the optional arena argument is non-NULL, blah blah * blah. XXX fgmr Should we include an nssASN1EncodingType argument, * as a hint? Or is each encoding distinctive? This routine may * return NULL upon error, in which case an error will have been * placed upon the error stack. * * The error may be one of the following values: * NSS_ERROR_NO_MEMORY * NSS_ERROR_INVALID_ARENA * NSS_ERROR_INVALID_POINTER * ... * * Return value: * NULL upon error * A pointer to an ASN.1 Decoder upon success. */ NSS_IMPLEMENT nssASN1Decoder * nssASN1Decoder_Create ( NSSArena *arenaOpt, void *destination, const nssASN1Template template[] ) { SEC_ASN1DecoderContext *rv; PLArenaPool *hack = (PLArenaPool *)arenaOpt; #ifdef DEBUG if( (NSSArena *)NULL != arenaOpt ) { if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) { return (nssASN1Decoder *)NULL; } } /* * May destination be NULL? I'd think so, since one might * have only a filter proc. But if not, check the pointer here. */ if( (nssASN1Template *)NULL == template ) { nss_SetError(NSS_ERROR_INVALID_POINTER); return (nssASN1Decoder *)NULL; } #endif /* DEBUG */ rv = SEC_ASN1DecoderStart(hack, destination, template); if( (SEC_ASN1DecoderContext *)NULL == rv ) { nss_SetError(PORT_GetError()); /* also evil */ return (nssASN1Decoder *)NULL; } #ifdef DEBUG if( PR_SUCCESS != decoder_add_pointer(rv) ) { (void)SEC_ASN1DecoderFinish(rv); return (nssASN1Decoder *)NULL; } #endif /* DEBUG */ return (nssASN1Decoder *)rv; } /* * nssASN1Decoder_Update * * This routine feeds data to the decoder. In the event of an error, * it will place an error on the error stack and return PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_NO_MEMORY * NSS_ERROR_INVALID_POINTER * NSS_ERROR_INVALID_ASN1DECODER * NSS_ERROR_INVALID_BER * ... * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success. */ NSS_IMPLEMENT PRStatus nssASN1Decoder_Update ( nssASN1Decoder *decoder, const void *data, PRUint32 amount ) { SECStatus rv; #ifdef DEBUG if( PR_SUCCESS != nssASN1Decoder_verify(decoder) ) { return PR_FAILURE; } if( (void *)NULL == data ) { nss_SetError(NSS_ERROR_INVALID_POINTER); return PR_FAILURE; } #endif /* DEBUG */ rv = SEC_ASN1DecoderUpdate((SEC_ASN1DecoderContext *)decoder, (const char *)data, (unsigned long)amount); if( SECSuccess != rv ) { nss_SetError(PORT_GetError()); /* ugly */ return PR_FAILURE; } return PR_SUCCESS; } /* * nssASN1Decoder_Finish * * This routine finishes the decoding and destroys the decoder. * In the event of an error, it will place an error on the error * stack and return PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1DECODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Decoder_Finish ( nssASN1Decoder *decoder ) { PRStatus rv = PR_SUCCESS; SECStatus srv; #ifdef DEBUG if( PR_SUCCESS != nssASN1Decoder_verify(decoder) ) { return PR_FAILURE; } #endif /* DEBUG */ srv = SEC_ASN1DecoderFinish((SEC_ASN1DecoderContext *)decoder); if( SECSuccess != srv ) { nss_SetError(PORT_GetError()); /* ugly */ rv = PR_FAILURE; } #ifdef DEBUG { PRStatus rv2 = decoder_remove_pointer(decoder); if( PR_SUCCESS == rv ) { rv = rv2; } } #endif /* DEBUG */ return rv; } /* * nssASN1Decoder_SetFilter * * This routine registers a callback filter routine with the decoder, * which will be called blah blah blah. The specified argument will * be passed as-is to the filter routine. The routine pointer may * be NULL, in which case no filter callback will be called. If the * noStore boolean is PR_TRUE, then decoded fields will not be stored * in the destination structure specified when the decoder was * created. This routine returns a PRStatus value; in the event of * an error, it will place an error on the error stack and return * PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1DECODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Decoder_SetFilter ( nssASN1Decoder *decoder, nssASN1DecoderFilterFunction *callback, void *argument, PRBool noStore ) { #ifdef DEBUG if( PR_SUCCESS != nssASN1Decoder_verify(decoder) ) { return PR_FAILURE; } #endif /* DEBUG */ if( (nssASN1DecoderFilterFunction *)NULL == callback ) { SEC_ASN1DecoderClearFilterProc((SEC_ASN1DecoderContext *)decoder); } else { SEC_ASN1DecoderSetFilterProc((SEC_ASN1DecoderContext *)decoder, (SEC_ASN1WriteProc)callback, argument, noStore); } /* No error returns defined for those routines */ return PR_SUCCESS; } /* * nssASN1Decoder_GetFilter * * If the optional pCallbackOpt argument to this routine is non-null, * then the pointer to any callback function established for this * decoder with nssASN1Decoder_SetFilter will be stored at the * location indicated by it. If the optional pArgumentOpt * pointer is non-null, the filter's closure argument will be stored * there. If the optional pNoStoreOpt pointer is non-null, the * noStore value specified when setting the filter will be stored * there. This routine returns a PRStatus value; in the event of * an error it will place an error on the error stack and return * PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1DECODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ extern const NSSError NSS_ERROR_INTERNAL_ERROR; NSS_IMPLEMENT PRStatus nssASN1Decoder_GetFilter ( nssASN1Decoder *decoder, nssASN1DecoderFilterFunction **pCallbackOpt, void **pArgumentOpt, PRBool *pNoStoreOpt ) { #ifdef DEBUG if( PR_SUCCESS != nssASN1Decoder_verify(decoder) ) { return PR_FAILURE; } #endif /* DEBUG */ if( (nssASN1DecoderFilterFunction **)NULL != pCallbackOpt ) { *pCallbackOpt = (nssASN1DecoderFilterFunction *)NULL; } if( (void **)NULL != pArgumentOpt ) { *pArgumentOpt = (void *)NULL; } if( (PRBool *)NULL != pNoStoreOpt ) { *pNoStoreOpt = PR_FALSE; } /* Error because it's unimplemented */ nss_SetError(NSS_ERROR_INTERNAL_ERROR); return PR_FAILURE; } /* * nssASN1Decoder_SetNotify * * This routine registers a callback notify routine with the decoder, * which will be called whenever.. The specified argument will be * passed as-is to the notify routine. The routine pointer may be * NULL, in which case no notify routine will be called. This routine * returns a PRStatus value; in the event of an error it will place * an error on the error stack and return PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1DECODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Decoder_SetNotify ( nssASN1Decoder *decoder, nssASN1NotifyFunction *callback, void *argument ) { #ifdef DEBUG if( PR_SUCCESS != nssASN1Decoder_verify(decoder) ) { return PR_FAILURE; } #endif /* DEBUG */ if( (nssASN1NotifyFunction *)NULL == callback ) { SEC_ASN1DecoderClearNotifyProc((SEC_ASN1DecoderContext *)decoder); } else { SEC_ASN1DecoderSetNotifyProc((SEC_ASN1DecoderContext *)decoder, (SEC_ASN1NotifyProc)callback, argument); } /* No error returns defined for those routines */ return PR_SUCCESS; } /* * nssASN1Decoder_GetNotify * * If the optional pCallbackOpt argument to this routine is non-null, * then the pointer to any callback function established for this * decoder with nssASN1Decoder_SetNotify will be stored at the * location indicated by it. If the optional pArgumentOpt pointer is * non-null, the filter's closure argument will be stored there. * This routine returns a PRStatus value; in the event of an error it * will place an error on the error stack and return PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1DECODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Decoder_GetNotify ( nssASN1Decoder *decoder, nssASN1NotifyFunction **pCallbackOpt, void **pArgumentOpt ) { #ifdef DEBUG if( PR_SUCCESS != nssASN1Decoder_verify(decoder) ) { return PR_FAILURE; } #endif /* DEBUG */ if( (nssASN1NotifyFunction **)NULL != pCallbackOpt ) { *pCallbackOpt = (nssASN1NotifyFunction *)NULL; } if( (void **)NULL != pArgumentOpt ) { *pArgumentOpt = (void *)NULL; } /* Error because it's unimplemented */ nss_SetError(NSS_ERROR_INTERNAL_ERROR); return PR_FAILURE; } /* * nssASN1_Decode * * This routine will decode the specified data into the specified * destination structure, as specified by the specified template. * This routine returns a PRStatus value; in the event of an error * it will place an error on the error stack and return PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_NO_MEMORY * NSS_ERROR_INVALID_ARENA * NSS_ERROR_INVALID_POINTER * NSS_ERROR_INVALID_BER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1_Decode ( NSSArena *arenaOpt, void *destination, const nssASN1Template template[], const void *berData, PRUint32 amount ) { PRStatus rv; nssASN1Decoder *decoder; /* This call will do our pointer-checking for us! */ decoder = nssASN1Decoder_Create(arenaOpt, destination, template); if( (nssASN1Decoder *)NULL == decoder ) { return PR_FAILURE; } rv = nssASN1Decoder_Update(decoder, berData, amount); if( PR_SUCCESS != nssASN1Decoder_Finish(decoder) ) { rv = PR_FAILURE; } return rv; } /* * nssASN1_DecodeBER * * This routine will decode the data in the specified NSSBER * into the destination structure, as specified by the template. * This routine returns a PRStatus value; in the event of an error * it will place an error on the error stack and return PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_NO_MEMORY * NSS_ERROR_INVALID_ARENA * NSS_ERROR_INVALID_POINTER * NSS_ERROR_INVALID_NSSBER * NSS_ERROR_INVALID_BER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1_DecodeBER ( NSSArena *arenaOpt, void *destination, const nssASN1Template template[], const NSSBER *data ) { return nssASN1_Decode(arenaOpt, destination, template, data->data, data->size); } /* * nssASN1Encoder_Create * * This routine creates an ASN.1 Encoder, blah blah blah. This * may return NULL upon error, in which case an error will have been * placed on the error stack. * * The error may be one of the following values: * NSS_ERROR_NO_MEMORY * NSS_ERROR_INVALID_ARENA * NSS_ERROR_INVALID_POINTER * ... * * Return value: * NULL upon error * A pointer to an ASN.1 Encoder upon success */ NSS_IMPLEMENT nssASN1Encoder * nssASN1Encoder_Create ( const void *source, const nssASN1Template template[], NSSASN1EncodingType encoding, nssASN1EncoderWriteFunction *sink, void *argument ) { SEC_ASN1EncoderContext *rv; #ifdef DEBUG if( (void *)NULL == source ) { nss_SetError(NSS_ERROR_INVALID_POINTER); return (nssASN1Encoder *)NULL; } if( (nssASN1Template *)NULL == template ) { nss_SetError(NSS_ERROR_INVALID_POINTER); return (nssASN1Encoder *)NULL; } if( (nssASN1EncoderWriteFunction *)NULL == sink ) { nss_SetError(NSS_ERROR_INVALID_POINTER); return (nssASN1Encoder *)NULL; } #endif /* DEBUG */ switch( encoding ) { case NSSASN1BER: case NSSASN1DER: break; case NSSASN1CER: case NSSASN1LWER: case NSSASN1PER: case NSSASN1UnknownEncoding: default: nss_SetError(NSS_ERROR_ENCODING_NOT_SUPPORTED); return (nssASN1Encoder *)NULL; } rv = SEC_ASN1EncoderStart((void *)source, template, (SEC_ASN1WriteProc)sink, argument); if( (SEC_ASN1EncoderContext *)NULL == rv ) { nss_SetError(PORT_GetError()); /* ugly */ return (nssASN1Encoder *)NULL; } if( NSSASN1DER == encoding ) { sec_ASN1EncoderSetDER(rv); } #ifdef DEBUG if( PR_SUCCESS != encoder_add_pointer(rv) ) { (void)SEC_ASN1EncoderFinish(rv); return (nssASN1Encoder *)NULL; } #endif /* DEBUG */ return (nssASN1Encoder *)rv; } /* * nssASN1Encoder_Update * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1ENCODER * NSS_ERROR_INVALID_POINTER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Encoder_Update ( nssASN1Encoder *encoder, const void *data, PRUint32 length ) { SECStatus rv; #ifdef DEBUG if( PR_SUCCESS != nssASN1Encoder_verify(encoder) ) { return PR_FAILURE; } /* * Can data legitimately be NULL? If not, verify.. */ #endif /* DEBUG */ rv = SEC_ASN1EncoderUpdate((SEC_ASN1EncoderContext *)encoder, (const char *)data, (unsigned long)length); if( SECSuccess != rv ) { nss_SetError(PORT_GetError()); /* ugly */ return PR_FAILURE; } return PR_SUCCESS; } /* * nssASN1Encoder_Finish * * Destructor. * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1ENCODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Encoder_Finish ( nssASN1Encoder *encoder ) { PRStatus rv; #ifdef DEBUG if( PR_SUCCESS != nssASN1Encoder_verify(encoder) ) { return PR_FAILURE; } #endif /* DEBUG */ SEC_ASN1EncoderFinish((SEC_ASN1EncoderContext *)encoder); rv = PR_SUCCESS; /* no error return defined for that call */ #ifdef DEBUG { PRStatus rv2 = encoder_remove_pointer(encoder); if( PR_SUCCESS == rv ) { rv = rv2; } } #endif /* DEBUG */ return rv; } /* * nssASN1Encoder_SetNotify * * This routine registers a callback notify routine with the encoder, * which will be called whenever.. The specified argument will be * passed as-is to the notify routine. The routine pointer may be * NULL, in which case no notify routine will be called. This routine * returns a PRStatus value; in the event of an error it will place * an error on the error stack and return PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1DECODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Encoder_SetNotify ( nssASN1Encoder *encoder, nssASN1NotifyFunction *callback, void *argument ) { #ifdef DEBUG if( PR_SUCCESS != nssASN1Encoder_verify(encoder) ) { return PR_FAILURE; } #endif /* DEBUG */ if( (nssASN1NotifyFunction *)NULL == callback ) { SEC_ASN1EncoderClearNotifyProc((SEC_ASN1EncoderContext *)encoder); } else { SEC_ASN1EncoderSetNotifyProc((SEC_ASN1EncoderContext *)encoder, (SEC_ASN1NotifyProc)callback, argument); } /* no error return defined for those routines */ return PR_SUCCESS; } /* * nssASN1Encoder_GetNotify * * If the optional pCallbackOpt argument to this routine is non-null, * then the pointer to any callback function established for this * decoder with nssASN1Encoder_SetNotify will be stored at the * location indicated by it. If the optional pArgumentOpt pointer is * non-null, the filter's closure argument will be stored there. * This routine returns a PRStatus value; in the event of an error it * will place an error on the error stack and return PR_FAILURE. * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1ENCODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Encoder_GetNotify ( nssASN1Encoder *encoder, nssASN1NotifyFunction **pCallbackOpt, void **pArgumentOpt ) { #ifdef DEBUG if( PR_SUCCESS != nssASN1Encoder_verify(encoder) ) { return PR_FAILURE; } #endif /* DEBUG */ if( (nssASN1NotifyFunction **)NULL != pCallbackOpt ) { *pCallbackOpt = (nssASN1NotifyFunction *)NULL; } if( (void **)NULL != pArgumentOpt ) { *pArgumentOpt = (void *)NULL; } /* Error because it's unimplemented */ nss_SetError(NSS_ERROR_INTERNAL_ERROR); return PR_FAILURE; } /* * nssASN1Encoder_SetStreaming * * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1ENCODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Encoder_SetStreaming ( nssASN1Encoder *encoder, PRBool streaming ) { SEC_ASN1EncoderContext *cx = (SEC_ASN1EncoderContext *)encoder; #ifdef DEBUG if( PR_SUCCESS != nssASN1Encoder_verify(encoder) ) { return PR_FAILURE; } #endif /* DEBUG */ if( streaming ) { SEC_ASN1EncoderSetStreaming(cx); } else { SEC_ASN1EncoderClearStreaming(cx); } /* no error return defined for those routines */ return PR_SUCCESS; } /* * nssASN1Encoder_GetStreaming * * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1ENCODER * NSS_ERROR_INVALID_POINTER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_EXTERN PRStatus nssASN1Encoder_GetStreaming ( nssASN1Encoder *encoder, PRBool *pStreaming ) { #ifdef DEBUG if( PR_SUCCESS != nssASN1Encoder_verify(encoder) ) { return PR_FAILURE; } #endif /* DEBUG */ if( (PRBool *)NULL != pStreaming ) { *pStreaming = PR_FALSE; } /* Error because it's unimplemented */ nss_SetError(NSS_ERROR_INTERNAL_ERROR); return PR_FAILURE; } /* * nssASN1Encoder_SetTakeFromBuffer * * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1ENCODER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Encoder_SetTakeFromBuffer ( nssASN1Encoder *encoder, PRBool takeFromBuffer ) { SEC_ASN1EncoderContext *cx = (SEC_ASN1EncoderContext *)encoder; #ifdef DEBUG if( PR_SUCCESS != nssASN1Encoder_verify(encoder) ) { return PR_FAILURE; } #endif /* DEBUG */ if( takeFromBuffer ) { SEC_ASN1EncoderSetTakeFromBuf(cx); } else { SEC_ASN1EncoderClearTakeFromBuf(cx); } /* no error return defined for those routines */ return PR_SUCCESS; } /* * nssASN1Encoder_GetTakeFromBuffer * * * The error may be one of the following values: * NSS_ERROR_INVALID_ASN1ENCODER * NSS_ERROR_INVALID_POINTER * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1Encoder_GetTakeFromBuffer ( nssASN1Encoder *encoder, PRBool *pTakeFromBuffer ) { #ifdef DEBUG if( PR_SUCCESS != nssASN1Encoder_verify(encoder) ) { return PR_FAILURE; } #endif /* DEBUG */ if( (PRBool *)NULL != pTakeFromBuffer ) { *pTakeFromBuffer = PR_FALSE; } /* Error because it's unimplemented */ nss_SetError(NSS_ERROR_INTERNAL_ERROR); return PR_FAILURE; } /* * nssASN1_Encode * * * The error may be one of the following values: * NSS_ERROR_NO_MEMORY * NSS_ERROR_INVALID_ARENA * NSS_ERROR_INVALID_POINTER * NSS_ERROR_ENCODING_NOT_SUPPORTED * ... * * Return value: * PR_FAILURE upon error * PR_SUCCESS upon success */ NSS_IMPLEMENT PRStatus nssASN1_Encode ( const void *source, const nssASN1Template template[], NSSASN1EncodingType encoding, nssASN1EncoderWriteFunction *sink, void *argument ) { PRStatus rv; nssASN1Encoder *encoder; encoder = nssASN1Encoder_Create(source, template, encoding, sink, argument); if( (nssASN1Encoder *)NULL == encoder ) { return PR_FAILURE; } rv = nssASN1Encoder_Update(encoder, (const void *)NULL, 0); if( PR_SUCCESS != nssASN1Encoder_Finish(encoder) ) { rv = PR_FAILURE; } return rv; } /* * nssasn1_encode_item_count * * This is a helper function for nssASN1_EncodeItem. It just counts * up the space required for an encoding. */ static void nssasn1_encode_item_count ( void *arg, const char *buf, unsigned long len, int depth, nssASN1EncodingPart data_kind ) { unsigned long *count; count = (unsigned long*)arg; PR_ASSERT (count != NULL); *count += len; } /* * nssasn1_encode_item_store * * This is a helper function for nssASN1_EncodeItem. It appends the * new data onto the destination item. */ static void nssasn1_encode_item_store ( void *arg, const char *buf, unsigned long len, int depth, nssASN1EncodingPart data_kind ) { NSSItem *dest; dest = (NSSItem*)arg; PR_ASSERT (dest != NULL); memcpy((unsigned char *)dest->data + dest->size, buf, len); dest->size += len; } /* * nssASN1_EncodeItem * * There must be a better name. If the optional arena argument is * non-null, it'll be used for the space. If the optional rvOpt is * non-null, it'll be the return value-- if it is null, a new one * will be allocated. * * The error may be one of the following values: * NSS_ERROR_NO_MEMORY * NSS_ERROR_INVALID_ARENA * NSS_ERROR_INVALID_POINTER * NSS_ERROR_ENCODING_NOT_SUPPORTED * * Return value: * NULL upon error * A valid pointer to an NSSDER upon success */ NSS_IMPLEMENT NSSDER * nssASN1_EncodeItem ( NSSArena *arenaOpt, NSSDER *rvOpt, const void *source, const nssASN1Template template[], NSSASN1EncodingType encoding ) { NSSDER *rv; PRUint32 len = 0; PRStatus status; #ifdef DEBUG if( (NSSArena *)NULL != arenaOpt ) { if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) { return (NSSDER *)NULL; } } if( (void *)NULL == source ) { nss_SetError(NSS_ERROR_INVALID_POINTER); return (NSSDER *)NULL; } if( (nssASN1Template *)NULL == template ) { nss_SetError(NSS_ERROR_INVALID_POINTER); return (NSSDER *)NULL; } #endif /* DEBUG */ status = nssASN1_Encode(source, template, encoding, (nssASN1EncoderWriteFunction *)nssasn1_encode_item_count, &len); if( PR_SUCCESS != status ) { return (NSSDER *)NULL; } if( (NSSDER *)NULL == rvOpt ) { rv = nss_ZNEW(arenaOpt, NSSDER); if( (NSSDER *)NULL == rv ) { return (NSSDER *)NULL; } } else { rv = rvOpt; } rv->size = len; rv->data = nss_ZAlloc(arenaOpt, len); if( (void *)NULL == rv->data ) { if( (NSSDER *)NULL == rvOpt ) { nss_ZFreeIf(rv); } return (NSSDER *)NULL; } rv->size = 0; /* for nssasn1_encode_item_store */ status = nssASN1_Encode(source, template, encoding, (nssASN1EncoderWriteFunction *)nssasn1_encode_item_store, rv); if( PR_SUCCESS != status ) { nss_ZFreeIf(rv->data); if( (NSSDER *)NULL == rvOpt ) { nss_ZFreeIf(rv); } return (NSSDER *)NULL; } PR_ASSERT(rv->size == len); return rv; } /* * nssASN1_CreatePRUint32FromBER * */ NSS_IMPLEMENT PRStatus nssASN1_CreatePRUint32FromBER ( NSSBER *encoded, PRUint32 *pResult ) { nss_SetError(NSS_ERROR_INTERNAL_ERROR); return PR_FALSE; } /* * nssASN1_GetDERFromPRUint32 * */ NSS_EXTERN NSSDER * nssASN1_GetDERFromPRUint32 ( NSSArena *arenaOpt, NSSDER *rvOpt, PRUint32 value ) { NSSDER *rv; PLArenaPool *hack = (PLArenaPool *)arenaOpt; SECItem *item; #ifdef DEBUG if( (NSSArena *)NULL != arenaOpt ) { if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) { return (NSSDER *)NULL; } } #endif /* DEBUG */ if( (NSSDER *)NULL == rvOpt ) { rv = nss_ZNEW(arenaOpt, NSSDER); if( (NSSDER *)NULL == rv ) { return (NSSDER *)NULL; } } else { rv = rvOpt; } item = SEC_ASN1EncodeUnsignedInteger(hack, (SECItem *)rv, value); if( (SECItem *)NULL == item ) { if( (NSSDER *)NULL == rvOpt ) { (void)nss_ZFreeIf(rv); } nss_SetError(PORT_GetError()); /* ugly */ return (NSSDER *)NULL; } /* * I happen to know that these things look alike.. but I'm only * doing it for these "temporary" wrappers. This is an evil thing. */ return (NSSDER *)item; } /*himom*/ NSS_IMPLEMENT PRStatus nssASN1_CreatePRInt32FromBER ( NSSBER *encoded, PRInt32 *pResult ) { nss_SetError(NSS_ERROR_INTERNAL_ERROR); return PR_FALSE; } /* * nssASN1_GetDERFromPRInt32 * */ NSS_IMPLEMENT NSSDER * nssASN1_GetDERFromPRInt32 ( NSSArena *arenaOpt, NSSDER *rvOpt, PRInt32 value ) { NSSDER *rv; PLArenaPool *hack = (PLArenaPool *)arenaOpt; SECItem *item; #ifdef DEBUG if( (NSSArena *)NULL != arenaOpt ) { if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) { return (NSSDER *)NULL; } } #endif /* DEBUG */ if( (NSSDER *)NULL == rvOpt ) { rv = nss_ZNEW(arenaOpt, NSSDER); if( (NSSDER *)NULL == rv ) { return (NSSDER *)NULL; } } else { rv = rvOpt; } item = SEC_ASN1EncodeInteger(hack, (SECItem *)rv, value); if( (SECItem *)NULL == item ) { if( (NSSDER *)NULL == rvOpt ) { (void)nss_ZFreeIf(rv); } nss_SetError(PORT_GetError()); /* ugly */ return (NSSDER *)NULL; } /* * I happen to know that these things look alike.. but I'm only * doing it for these "temporary" wrappers. This is an evil thing. */ return (NSSDER *)item; } /* * Generic Templates * One for each of the simple types, plus a special one for ANY, plus: * - a pointer to each one of those * - a set of each one of those * * Note that these are alphabetical (case insensitive); please add new * ones in the appropriate place. */ const nssASN1Template *nssASN1Template_Any = (nssASN1Template *)SEC_AnyTemplate; const nssASN1Template *nssASN1Template_BitString = (nssASN1Template *)SEC_BitStringTemplate; const nssASN1Template *nssASN1Template_BMPString = (nssASN1Template *)SEC_BMPStringTemplate; const nssASN1Template *nssASN1Template_Boolean = (nssASN1Template *)SEC_BooleanTemplate; const nssASN1Template *nssASN1Template_Enumerated = (nssASN1Template *)SEC_EnumeratedTemplate; const nssASN1Template *nssASN1Template_GeneralizedTime = (nssASN1Template *)SEC_GeneralizedTimeTemplate; const nssASN1Template *nssASN1Template_IA5String = (nssASN1Template *)SEC_IA5StringTemplate; const nssASN1Template *nssASN1Template_Integer = (nssASN1Template *)SEC_IntegerTemplate; const nssASN1Template *nssASN1Template_Null = (nssASN1Template *)SEC_NullTemplate; const nssASN1Template *nssASN1Template_ObjectID = (nssASN1Template *)SEC_ObjectIDTemplate; const nssASN1Template *nssASN1Template_OctetString = (nssASN1Template *)SEC_OctetStringTemplate; const nssASN1Template *nssASN1Template_PrintableString = (nssASN1Template *)SEC_PrintableStringTemplate; const nssASN1Template *nssASN1Template_T61String = (nssASN1Template *)SEC_T61StringTemplate; const nssASN1Template *nssASN1Template_UniversalString = (nssASN1Template *)SEC_UniversalStringTemplate; const nssASN1Template *nssASN1Template_UTCTime = (nssASN1Template *)SEC_UTCTimeTemplate; const nssASN1Template *nssASN1Template_UTF8String = (nssASN1Template *)SEC_UTF8StringTemplate; const nssASN1Template *nssASN1Template_VisibleString = (nssASN1Template *)SEC_VisibleStringTemplate; const nssASN1Template *nssASN1Template_PointerToAny = (nssASN1Template *)SEC_PointerToAnyTemplate; const nssASN1Template *nssASN1Template_PointerToBitString = (nssASN1Template *)SEC_PointerToBitStringTemplate; const nssASN1Template *nssASN1Template_PointerToBMPString = (nssASN1Template *)SEC_PointerToBMPStringTemplate; const nssASN1Template *nssASN1Template_PointerToBoolean = (nssASN1Template *)SEC_PointerToBooleanTemplate; const nssASN1Template *nssASN1Template_PointerToEnumerated = (nssASN1Template *)SEC_PointerToEnumeratedTemplate; const nssASN1Template *nssASN1Template_PointerToGeneralizedTime = (nssASN1Template *)SEC_PointerToGeneralizedTimeTemplate; const nssASN1Template *nssASN1Template_PointerToIA5String = (nssASN1Template *)SEC_PointerToIA5StringTemplate; const nssASN1Template *nssASN1Template_PointerToInteger = (nssASN1Template *)SEC_PointerToIntegerTemplate; const nssASN1Template *nssASN1Template_PointerToNull = (nssASN1Template *)SEC_PointerToNullTemplate; const nssASN1Template *nssASN1Template_PointerToObjectID = (nssASN1Template *)SEC_PointerToObjectIDTemplate; const nssASN1Template *nssASN1Template_PointerToOctetString = (nssASN1Template *)SEC_PointerToOctetStringTemplate; const nssASN1Template *nssASN1Template_PointerToPrintableString = (nssASN1Template *)SEC_PointerToPrintableStringTemplate; const nssASN1Template *nssASN1Template_PointerToT61String = (nssASN1Template *)SEC_PointerToT61StringTemplate; const nssASN1Template *nssASN1Template_PointerToUniversalString = (nssASN1Template *)SEC_PointerToUniversalStringTemplate; const nssASN1Template *nssASN1Template_PointerToUTCTime = (nssASN1Template *)SEC_PointerToUTCTimeTemplate; const nssASN1Template *nssASN1Template_PointerToUTF8String = (nssASN1Template *)SEC_PointerToUTF8StringTemplate; const nssASN1Template *nssASN1Template_PointerToVisibleString = (nssASN1Template *)SEC_PointerToVisibleStringTemplate; const nssASN1Template *nssASN1Template_SetOfAny = (nssASN1Template *)SEC_SetOfAnyTemplate; const nssASN1Template *nssASN1Template_SetOfBitString = (nssASN1Template *)SEC_SetOfBitStringTemplate; const nssASN1Template *nssASN1Template_SetOfBMPString = (nssASN1Template *)SEC_SetOfBMPStringTemplate; const nssASN1Template *nssASN1Template_SetOfBoolean = (nssASN1Template *)SEC_SetOfBooleanTemplate; const nssASN1Template *nssASN1Template_SetOfEnumerated = (nssASN1Template *)SEC_SetOfEnumeratedTemplate; const nssASN1Template *nssASN1Template_SetOfGeneralizedTime = (nssASN1Template *)SEC_SetOfGeneralizedTimeTemplate; const nssASN1Template *nssASN1Template_SetOfIA5String = (nssASN1Template *)SEC_SetOfIA5StringTemplate; const nssASN1Template *nssASN1Template_SetOfInteger = (nssASN1Template *)SEC_SetOfIntegerTemplate; const nssASN1Template *nssASN1Template_SetOfNull = (nssASN1Template *)SEC_SetOfNullTemplate; const nssASN1Template *nssASN1Template_SetOfObjectID = (nssASN1Template *)SEC_SetOfObjectIDTemplate; const nssASN1Template *nssASN1Template_SetOfOctetString = (nssASN1Template *)SEC_SetOfOctetStringTemplate; const nssASN1Template *nssASN1Template_SetOfPrintableString = (nssASN1Template *)SEC_SetOfPrintableStringTemplate; const nssASN1Template *nssASN1Template_SetOfT61String = (nssASN1Template *)SEC_SetOfT61StringTemplate; const nssASN1Template *nssASN1Template_SetOfUniversalString = (nssASN1Template *)SEC_SetOfUniversalStringTemplate; const nssASN1Template *nssASN1Template_SetOfUTCTime = (nssASN1Template *)SEC_SetOfUTCTimeTemplate; const nssASN1Template *nssASN1Template_SetOfUTF8String = (nssASN1Template *)SEC_SetOfUTF8StringTemplate; const nssASN1Template *nssASN1Template_SetOfVisibleString = (nssASN1Template *)SEC_SetOfVisibleStringTemplate; /* * */ NSS_IMPLEMENT NSSUTF8 * nssUTF8_CreateFromBER ( NSSArena *arenaOpt, nssStringType type, NSSBER *berData ) { NSSUTF8 *rv = NULL; PRUint8 tag; NSSArena *a; NSSItem in; NSSItem out; PRStatus st; const nssASN1Template *templ; #ifdef NSSDEBUG if( (NSSArena *)NULL != arenaOpt ) { if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) { return (NSSUTF8 *)NULL; } } if( (NSSBER *)NULL == berData ) { nss_SetError(NSS_ERROR_INVALID_POINTER); return (NSSUTF8 *)NULL; } if( (void *)NULL == berData->data ) { nss_SetError(NSS_ERROR_INVALID_POINTER); return (NSSUTF8 *)NULL; } #endif /* NSSDEBUG */ a = NSSArena_Create(); if( (NSSArena *)NULL == a ) { return (NSSUTF8 *)NULL; } in = *berData; /* * By the way, at first I succumbed to the temptation to make * this an incestuous nested switch statement. Count yourself * lucky I cleaned it up. */ switch( type ) { case nssStringType_DirectoryString: /* * draft-ietf-pkix-ipki-part1-11 says in part: * * DirectoryString { INTEGER:maxSize } ::= CHOICE { * teletexString TeletexString (SIZE (1..maxSize)), * printableString PrintableString (SIZE (1..maxSize)), * universalString UniversalString (SIZE (1..maxSize)), * bmpString BMPString (SIZE(1..maxSize)), * utf8String UTF8String (SIZE(1..maxSize)) * } * * The tags are: * TeletexString UNIVERSAL 20 * PrintableString UNIVERSAL 19 * UniversalString UNIVERSAL 28 * BMPString UNIVERSAL 30 * UTF8String UNIVERSAL 12 * * "UNIVERSAL" tags have bits 8 and 7 zero, bit 6 is zero for * primitive encodings, and if the tag value is less than 30, * the tag value is directly encoded in bits 5 through 1. */ in.data = (void *)&(((PRUint8 *)berData->data)[1]); in.size = berData->size-1; tag = *(PRUint8 *)berData->data; switch( tag & nssASN1_TAGNUM_MASK ) { case 20: /* * XXX fgmr-- we have to accept Latin-1 for Teletex; (see * below) but is T61 a suitable value for "Latin-1"? */ templ = nssASN1Template_T61String; type = nssStringType_TeletexString; break; case 19: templ = nssASN1Template_PrintableString; type = nssStringType_PrintableString; break; case 28: templ = nssASN1Template_UniversalString; type = nssStringType_UniversalString; break; case 30: templ = nssASN1Template_BMPString; type = nssStringType_BMPString; break; case 12: templ = nssASN1Template_UTF8String; type = nssStringType_UTF8String; break; default: nss_SetError(NSS_ERROR_INVALID_POINTER); /* "pointer"? */ (void)NSSArena_Destroy(a); return (NSSUTF8 *)NULL; } break; case nssStringType_TeletexString: /* * XXX fgmr-- we have to accept Latin-1 for Teletex; (see * below) but is T61 a suitable value for "Latin-1"? */ templ = nssASN1Template_T61String; break; case nssStringType_PrintableString: templ = nssASN1Template_PrintableString; break; case nssStringType_UniversalString: templ = nssASN1Template_UniversalString; break; case nssStringType_BMPString: templ = nssASN1Template_BMPString; break; case nssStringType_UTF8String: templ = nssASN1Template_UTF8String; break; case nssStringType_PHGString: templ = nssASN1Template_IA5String; break; default: nss_SetError(NSS_ERROR_UNSUPPORTED_TYPE); (void)NSSArena_Destroy(a); return (NSSUTF8 *)NULL; } st = nssASN1_DecodeBER(a, &out, templ, &in); if( PR_SUCCESS == st ) { rv = nssUTF8_Create(arenaOpt, type, out.data, out.size); } (void)NSSArena_Destroy(a); return rv; } NSS_EXTERN NSSDER * nssUTF8_GetDEREncoding ( NSSArena *arenaOpt, nssStringType type, const NSSUTF8 *string ) { NSSDER *rv = (NSSDER *)NULL; NSSItem str; NSSDER *der; const nssASN1Template *templ; NSSArena *a; #ifdef NSSDEBUG if( (NSSArena *)NULL != arenaOpt ) { if( PR_SUCCESS != nssArena_verifyPointer(arenaOpt) ) { return (NSSDER *)NULL; } } if( (const NSSUTF8 *)NULL == string ) { nss_SetError(NSS_ERROR_INVALID_POINTER); return (NSSDER *)NULL; } #endif /* NSSDEBUG */ str.data = (void *)string; str.size = nssUTF8_Size(string, (PRStatus *)NULL); if( 0 == str.size ) { return (NSSDER *)NULL; } a = NSSArena_Create(); if( (NSSArena *)NULL == a ) { return (NSSDER *)NULL; } switch( type ) { case nssStringType_DirectoryString: { NSSDER *utf; PRUint8 *c; utf = nssASN1_EncodeItem(a, (NSSDER *)NULL, &str, nssASN1Template_UTF8String, NSSASN1DER); if( (NSSDER *)NULL == utf ) { (void)NSSArena_Destroy(a); return (NSSDER *)NULL; } rv = nss_ZNEW(arenaOpt, NSSDER); if( (NSSDER *)NULL == rv ) { (void)NSSArena_Destroy(a); return (NSSDER *)NULL; } rv->size = utf->size + 1; rv->data = nss_ZAlloc(arenaOpt, rv->size); if( (void *)NULL == rv->data ) { (void)nss_ZFreeIf(rv); (void)NSSArena_Destroy(a); return (NSSDER *)NULL; } c = (PRUint8 *)rv->data; (void)nsslibc_memcpy(&c[1], utf->data, utf->size); *c = 12; /* UNIVERSAL primitive encoding tag for UTF8String */ (void)NSSArena_Destroy(a); return rv; } case nssStringType_TeletexString: /* * XXX fgmr-- we have to accept Latin-1 for Teletex; (see * below) but is T61 a suitable value for "Latin-1"? */ templ = nssASN1Template_T61String; break; case nssStringType_PrintableString: templ = nssASN1Template_PrintableString; break; case nssStringType_UniversalString: templ = nssASN1Template_UniversalString; break; case nssStringType_BMPString: templ = nssASN1Template_BMPString; break; case nssStringType_UTF8String: templ = nssASN1Template_UTF8String; break; case nssStringType_PHGString: templ = nssASN1Template_IA5String; break; default: nss_SetError(NSS_ERROR_UNSUPPORTED_TYPE); (void)NSSArena_Destroy(a); return (NSSDER *)NULL; } der = nssUTF8_GetDEREncoding(a, type, string); if( (NSSItem *)NULL == der ) { (void)NSSArena_Destroy(a); return (NSSDER *)NULL; } rv = nssASN1_EncodeItem(arenaOpt, (NSSDER *)NULL, der, templ, NSSASN1DER); if( (NSSDER *)NULL == rv ) { (void)NSSArena_Destroy(a); return (NSSDER *)NULL; } (void)NSSArena_Destroy(a); return rv; }