xmlsec-shim 1.2.18.1

data/vendor/xmlsec1-1.2.18/apps/cmdline.c

@@ -0,0 +1,355 @@
+/** 
+ *
+ * XMLSec library
+ * 
+ * 
+ * See Copyright for the status of this software.
+ * 
+ * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
+ */
+#if defined(_MSC_VER)
+#define snprintf _snprintf
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+#include <assert.h>
+
+#include "cmdline.h"
+
+static int                      xmlSecAppCmdLineMatchParam      (const char* argvParam,
+                                                                 const char* paramName,
+                                                                 int canHaveNameString);
+static xmlSecAppCmdLineParamPtr xmlSecAppCmdLineParamsListFind  (xmlSecAppCmdLineParamPtr* params,
+                                                                 xmlSecAppCmdLineParamTopic topics,
+                                                                 const char* name);
+static int                      xmlSecAppCmdLineParamRead       (xmlSecAppCmdLineParamPtr param,
+                                                                 const char** argv, 
+                                                                 int argc, 
+                                                                 int pos);
+static int                      xmlSecAppCmdLineTimeParamRead   (const char* str, 
+                                                                 time_t* t);
+
+int
+xmlSecAppCmdLineParamIsSet(xmlSecAppCmdLineParamPtr param) {
+    return(((param != NULL) && (param->value != NULL)) ? 1 : 0);
+}
+
+const char* 
+xmlSecAppCmdLineParamGetString(xmlSecAppCmdLineParamPtr param) {
+    if(param->type != xmlSecAppCmdLineParamTypeString) {
+        fprintf(stderr, "Error: parameter \"%s\" is not string.\n", param->fullName);
+        return(NULL);
+    }
+    return((param->value != NULL) ? param->value->strValue : NULL);
+}
+
+const char* 
+xmlSecAppCmdLineParamGetStringList(xmlSecAppCmdLineParamPtr param) {
+    if(param->type != xmlSecAppCmdLineParamTypeStringList) {
+        fprintf(stderr, "Error: parameter \"%s\" is not string list.\n", param->fullName);
+        return(NULL);
+    }
+    return((param->value != NULL) ? param->value->strListValue : NULL);
+}
+
+int 
+xmlSecAppCmdLineParamGetInt(xmlSecAppCmdLineParamPtr param, int def) {
+    if(param->type != xmlSecAppCmdLineParamTypeNumber) {
+        fprintf(stderr, "Error: parameter \"%s\" is not integer.\n", param->fullName);
+        return(def);
+    }
+    return((param->value != NULL) ? param->value->intValue : def);
+}
+
+time_t
+xmlSecAppCmdLineParamGetTime(xmlSecAppCmdLineParamPtr param, time_t def) {
+    if(param->type != xmlSecAppCmdLineParamTypeTime) {
+        fprintf(stderr, "Error: parameter \"%s\" is not time.\n", param->fullName);
+        return(def);
+    }
+    return((param->value != NULL) ? param->value->timeValue : def);
+}
+
+int 
+xmlSecAppCmdLineParamsListParse(xmlSecAppCmdLineParamPtr* params,
+                                xmlSecAppCmdLineParamTopic topics,
+                                const char** argv, int argc, int pos) {
+    xmlSecAppCmdLineParamPtr param;
+    int ii;
+    int ret;
+    
+    assert(params != NULL);
+    assert(argv != NULL);
+    
+    while((pos < argc) && (argv[pos][0] == '-')) {
+        param = xmlSecAppCmdLineParamsListFind(params, topics, argv[pos]);
+        if(param == NULL) {
+            fprintf(stderr, "Error: parameter \"%s\" is not supported or the requested\nfeature might have been disabled during compilation.\n", argv[pos]);
+            return(-1);
+        }
+        
+        ret = xmlSecAppCmdLineParamRead(param, argv, argc, pos);
+        if(ret < pos) {
+            fprintf(stderr, "Error: failed to parse parameter \"%s\".\n", argv[pos]);
+            return(-1);
+        }
+        pos = ret + 1;
+    }
+    
+    /* check that all parameters at the end are filenames */
+    for(ii = pos; (ii < argc); ++ii) {
+        if(argv[ii][0] == '-') {
+            fprintf(stderr, "Error: filename is expected instead of parameter \"%s\".\n", argv[ii]);
+            return(-1);
+            
+        }
+    }
+    
+    
+    
+    return(pos);
+}
+
+void 
+xmlSecAppCmdLineParamsListClean(xmlSecAppCmdLineParamPtr* params) {
+    xmlSecAppCmdLineValuePtr tmp;
+    size_t i;
+    
+    assert(params != NULL);
+    
+    for(i = 0; params[i] != NULL; ++i) {
+        while(params[i]->value != NULL) {
+            tmp = params[i]->value;
+            params[i]->value = params[i]->value->next;
+            xmlSecAppCmdLineValueDestroy(tmp);
+        }
+    }
+}
+
+void 
+xmlSecAppCmdLineParamsListPrint(xmlSecAppCmdLineParamPtr* params,
+                                xmlSecAppCmdLineParamTopic topics,
+                                FILE* output) {
+    size_t i;
+
+    assert(params != NULL);
+    assert(output != NULL);
+    
+    for(i = 0; params[i] != NULL; ++i) {
+        if(((params[i]->topics & topics) != 0) && (params[i]->help != NULL)) {
+            fprintf(output, "  %s\n", params[i]->help);
+        }
+    }    
+}
+
+xmlSecAppCmdLineValuePtr 
+xmlSecAppCmdLineValueCreate(xmlSecAppCmdLineParamPtr param, int pos) {
+    xmlSecAppCmdLineValuePtr value;
+    
+    assert(param != NULL);
+    value = (xmlSecAppCmdLineValuePtr) malloc(sizeof(xmlSecAppCmdLineValue));
+    if(value == NULL) {
+        fprintf(stderr, "Error: malloc failed (%d bytes).\n", sizeof(xmlSecAppCmdLineValue));
+        return(NULL);
+    }
+    memset(value, 0, sizeof(xmlSecAppCmdLineValue));
+    
+    value->param = param;
+    value->pos = pos;
+    return(value);
+}
+
+void 
+xmlSecAppCmdLineValueDestroy(xmlSecAppCmdLineValuePtr value) {
+    assert(value != NULL);
+    
+    if(value->strListValue != NULL) {
+        free((void*)value->strListValue);
+    }
+    free(value);
+}
+
+static int 
+xmlSecAppCmdLineMatchParam(const char* argvParam, const char* paramName,
+                           int canHaveNameString) {
+    assert(argvParam != NULL);
+    assert(paramName != NULL);
+    
+    if(canHaveNameString != 0) {
+        int len = strlen(paramName);
+        
+        if((strncmp(argvParam, paramName, len) == 0) &&
+           ((argvParam[len] == '\0') || (argvParam[len] == ':'))) {
+           
+           return(1);
+        }
+    } else if(strcmp(argvParam, paramName) == 0) {
+        return(1);
+    }
+    return(0);
+}
+
+static xmlSecAppCmdLineParamPtr 
+xmlSecAppCmdLineParamsListFind(xmlSecAppCmdLineParamPtr* params, xmlSecAppCmdLineParamTopic topics,
+                                const char* name) {
+    size_t i;
+    int canHaveNameString;
+
+    assert(params != NULL);
+    assert(name != NULL);
+
+    for(i = 0; params[i] != NULL; ++i) {
+        if((params[i]->topics & topics) == 0) {
+            continue;
+        }
+
+        canHaveNameString = ((params[i]->flags & xmlSecAppCmdLineParamFlagParamNameValue) != 0) ? 1 : 0;
+        if((params[i]->fullName != NULL) && 
+           (xmlSecAppCmdLineMatchParam(name, params[i]->fullName, canHaveNameString) == 1)) {
+        
+            return(params[i]);
+        }
+
+        if((params[i]->shortName != NULL) && 
+           (xmlSecAppCmdLineMatchParam(name, params[i]->shortName, canHaveNameString) == 1)) {
+        
+            return(params[i]);
+        }
+    }
+    
+    return(NULL);
+}
+
+static int 
+xmlSecAppCmdLineParamRead(xmlSecAppCmdLineParamPtr param, const char** argv, int argc, int pos) {
+    xmlSecAppCmdLineValuePtr value;
+    xmlSecAppCmdLineValuePtr prev = NULL;
+    char* buf;
+        
+    assert(param != NULL);
+    assert(argv != NULL);
+    assert(pos < argc);
+    
+    /* first find the previous value in the list */
+    if((param->flags & xmlSecAppCmdLineParamFlagMultipleValues) != 0) {
+        prev = param->value; 
+        while((prev != NULL) && (prev->next != NULL)) {
+            prev = prev->next; 
+        }
+    } else if(param->value != NULL) {
+        fprintf(stderr, "Error: only one parameter \"%s\" is allowed.\n", argv[pos]);
+        return(-1);
+    }
+    
+    /* create new value and add to the list */
+    value = xmlSecAppCmdLineValueCreate(param, pos);
+    if(value == NULL) {
+        fprintf(stderr, "Error: failed to create value for parameter \"%s\".\n", argv[pos]);
+        return(-1);
+    }
+    if(prev != NULL) {
+        assert(prev->next == NULL);
+        prev->next = value;
+    } else {
+        param->value = value;
+    }
+        
+    /* if we can have a string value after the name, parse it */
+    if((param->flags & xmlSecAppCmdLineParamFlagParamNameValue) != 0) {
+        value->paramNameValue = strchr(argv[pos], ':');
+        if(value->paramNameValue != NULL) {
+            ++value->paramNameValue;
+        }
+    }
+    
+    switch(param->type) {
+        case xmlSecAppCmdLineParamTypeFlag:
+            /* do nothing */
+            break;
+        case xmlSecAppCmdLineParamTypeString:
+            if(pos + 1 >= argc) {
+                fprintf(stderr, "Error: string argument expected for parameter \"%s\".\n", argv[pos]);
+                return(-1);
+            }
+            value->strValue = argv[++pos];
+            break;
+        case xmlSecAppCmdLineParamTypeStringList:
+            if(pos + 1 >= argc) {
+                fprintf(stderr, "Error: string list argument expected for parameter \"%s\".\n", argv[pos]);
+                return(-1);
+            }
+            value->strValue = argv[++pos];
+            buf = (char*)malloc(strlen(value->strValue) + 2);
+            if(buf == NULL) {
+                fprintf(stderr, "Error: failed to allocate memory (%d bytes).\n", strlen(value->strValue) + 2);
+                return(-1);
+            }
+            memset(buf, 0, strlen(value->strValue) + 2);
+            memcpy(buf, value->strValue, strlen(value->strValue));
+            value->strListValue = buf;
+            while((*buf) != '\0') {
+                if((*buf) == ',') {
+                    (*buf) = '\0';
+                }
+                ++buf;
+            }
+            break;
+        case xmlSecAppCmdLineParamTypeNumber:
+            if(pos + 1 >= argc) {
+                fprintf(stderr, "Error: integer argument expected for parameter \"%s\".\n", argv[pos]);
+                return(-1);
+            }    
+            value->strValue = argv[++pos];
+            if(sscanf(value->strValue, "%d", &(value->intValue)) != 1) {
+                fprintf(stderr, "Error: integer argument \"%s\" is invalid.\n", value->strValue);
+                return(-1);
+            }    
+            break;
+        case xmlSecAppCmdLineParamTypeTime:
+            if(pos + 1 >= argc) {
+                fprintf(stderr, "Error: time argument expected for parameter \"%s\".\n", argv[pos]);
+                return(-1);
+            }
+            value->strValue = argv[++pos];
+            if(xmlSecAppCmdLineTimeParamRead(value->strValue, &(value->timeValue)) < 0) {
+                fprintf(stderr, "Error: time argument \"%s\" is invalid, expected format is \"YYYY-MM-DD HH:MM:SS\").\n", value->strValue);
+                return(-1);
+            }    
+            break;
+    }
+    return(pos);
+}
+
+static int  
+xmlSecAppCmdLineTimeParamRead(const char* str, time_t* t) {
+    struct tm tm;
+    int n;
+    
+    if((str == NULL) || (t == NULL)) {
+        return(-1);
+    }
+    memset(&tm, 0, sizeof(tm));
+    tm.tm_isdst = -1;
+    
+    n = sscanf(str, "%4d-%2d-%2d%*c%2d:%2d:%2d", 
+                            &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
+                            &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
+    if((n != 6) || (tm.tm_year < 1900) 
+                || (tm.tm_mon  < 1) || (tm.tm_mon  > 12) 
+                || (tm.tm_mday < 1) || (tm.tm_mday > 31)
+                || (tm.tm_hour < 0) || (tm.tm_hour > 23)
+                || (tm.tm_min  < 0) || (tm.tm_min  > 59)
+                || (tm.tm_sec  < 0) || (tm.tm_sec  > 61)) {
+        return(-1);         
+    }
+
+    tm.tm_year -= 1900; /* tm relative format year */
+    tm.tm_mon  -= 1; /* tm relative format month */
+
+    (*t) = mktime(&tm);
+    return(0);    
+}
+

data/vendor/xmlsec1-1.2.18/apps/cmdline.h

@@ -0,0 +1,89 @@
+/** 
+ * XMLSec library
+ * 
+ * Command line parsing routines
+ *
+ * See Copyright for the status of this software.
+ * 
+ * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
+ */
+#ifndef __XMLSEC_APPS_CMDLINE_H__
+#define __XMLSEC_APPS_CMDLINE_H__    
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */ 
+
+#include <time.h>
+
+typedef struct _xmlSecAppCmdLineParam           xmlSecAppCmdLineParam,
+                                                *xmlSecAppCmdLineParamPtr;
+typedef struct _xmlSecAppCmdLineValue           xmlSecAppCmdLineValue,
+                                                *xmlSecAppCmdLineValuePtr;
+typedef unsigned int                            xmlSecAppCmdLineParamTopic;
+
+#define xmlSecAppCmdLineParamFlagNone                   0x0000
+#define xmlSecAppCmdLineParamFlagParamNameValue         0x0001
+#define xmlSecAppCmdLineParamFlagMultipleValues         0x0002
+
+typedef enum {
+    xmlSecAppCmdLineParamTypeFlag,
+    xmlSecAppCmdLineParamTypeString,
+    xmlSecAppCmdLineParamTypeStringList,
+    xmlSecAppCmdLineParamTypeNumber,
+    xmlSecAppCmdLineParamTypeTime
+} xmlSecAppCmdLineParamType;
+
+struct _xmlSecAppCmdLineParam {
+    xmlSecAppCmdLineParamTopic  topics;
+    const char*                 fullName;
+    const char*                 shortName;
+    const char*                 help;
+    xmlSecAppCmdLineParamType   type;
+    int                         flags;
+    xmlSecAppCmdLineValuePtr    value;
+};
+
+int             xmlSecAppCmdLineParamIsSet              (xmlSecAppCmdLineParamPtr param);
+const char*     xmlSecAppCmdLineParamGetString          (xmlSecAppCmdLineParamPtr param);
+const char*     xmlSecAppCmdLineParamGetStringList      (xmlSecAppCmdLineParamPtr param);
+int             xmlSecAppCmdLineParamGetInt             (xmlSecAppCmdLineParamPtr param,
+                                                         int def);
+time_t          xmlSecAppCmdLineParamGetTime            (xmlSecAppCmdLineParamPtr param,
+                                                         time_t def);
+
+int             xmlSecAppCmdLineParamsListParse         (xmlSecAppCmdLineParamPtr* params,
+                                                         xmlSecAppCmdLineParamTopic topcis,
+                                                         const char** argv,
+                                                         int argc,
+                                                         int pos);
+void            xmlSecAppCmdLineParamsListClean         (xmlSecAppCmdLineParamPtr* params);
+void            xmlSecAppCmdLineParamsListPrint         (xmlSecAppCmdLineParamPtr* params,
+                                                         xmlSecAppCmdLineParamTopic topic,
+                                                         FILE* output);
+
+struct _xmlSecAppCmdLineValue {
+    xmlSecAppCmdLineParamPtr    param;
+    int                         pos;
+    const char*                 paramNameValue;
+    const char*                 strValue;
+    const char*                 strListValue;
+    int                         intValue;
+    time_t                      timeValue;
+    xmlSecAppCmdLineValuePtr    next;
+};
+
+
+xmlSecAppCmdLineValuePtr xmlSecAppCmdLineValueCreate    (xmlSecAppCmdLineParamPtr param,
+                                                         int pos);
+void                     xmlSecAppCmdLineValueDestroy   (xmlSecAppCmdLineValuePtr value);                                                                
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __XMLSEC_APPS_CMDLINE_H__ */
+
+
+

data/vendor/xmlsec1-1.2.18/apps/crypto.c

@@ -0,0 +1,396 @@
+/** 
+ *
+ * XMLSec library
+ * 
+ * 
+ * See Copyright for the status of this software.
+ * 
+ * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
+ */
+#if defined(_MSC_VER)
+#define snprintf _snprintf
+#endif
+
+#include <string.h>
+
+#include <xmlsec/xmlsec.h>
+#include <xmlsec/keys.h>
+#include <xmlsec/transforms.h>
+#include <xmlsec/errors.h>
+
+#include "crypto.h"
+
+int
+xmlSecAppCryptoInit(const char* config) {
+    if(xmlSecCryptoAppInit(config) < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecCryptoAppInit",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);
+    }
+    if(xmlSecCryptoInit() < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecCryptoInit",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);
+    }
+    
+    return(0);
+}
+
+int
+xmlSecAppCryptoShutdown(void) {
+    if(xmlSecCryptoShutdown() < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecCryptoShutdown",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);
+    }
+
+    if(xmlSecCryptoAppShutdown() < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecCryptoAppShutdown",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);
+    }
+    return(0);
+}
+
+int
+xmlSecAppCryptoSimpleKeysMngrInit(xmlSecKeysMngrPtr mngr) {
+    xmlSecAssert2(mngr != NULL, -1);
+
+    return(xmlSecCryptoAppDefaultKeysMngrInit(mngr));
+}
+
+int
+xmlSecAppCryptoSimpleKeysMngrLoad(xmlSecKeysMngrPtr mngr, const char *filename) {
+    xmlSecAssert2(mngr != NULL, -1);
+    xmlSecAssert2(filename != NULL, -1);
+    
+    return(xmlSecCryptoAppDefaultKeysMngrLoad(mngr, filename));
+}
+
+int 
+xmlSecAppCryptoSimpleKeysMngrSave(xmlSecKeysMngrPtr mngr, const char *filename, xmlSecKeyDataType type) {
+    xmlSecAssert2(mngr != NULL, -1);
+    xmlSecAssert2(filename != NULL, -1);
+    
+    return(xmlSecCryptoAppDefaultKeysMngrSave(mngr, filename, type));
+}
+
+int 
+xmlSecAppCryptoSimpleKeysMngrCertLoad(xmlSecKeysMngrPtr mngr, const char *filename, 
+                                      xmlSecKeyDataFormat format, xmlSecKeyDataType type) {
+    xmlSecAssert2(mngr != NULL, -1);
+    xmlSecAssert2(filename != NULL, -1);
+
+#ifndef XMLSEC_NO_X509      
+    return(xmlSecCryptoAppKeysMngrCertLoad(mngr, filename, format, type));
+#else /* XMLSEC_NO_X509 */
+    return(-1);
+#endif /* XMLSEC_NO_X509 */    
+}
+
+int 
+xmlSecAppCryptoSimpleKeysMngrKeyAndCertsLoad(xmlSecKeysMngrPtr mngr, 
+                                             const char* files, const char* pwd, 
+                                             const char* name, 
+                                             xmlSecKeyDataFormat format) {
+    xmlSecKeyPtr key;
+    int ret;
+
+    xmlSecAssert2(mngr != NULL, -1);
+    xmlSecAssert2(files != NULL, -1);
+
+    /* first is the key file */
+    key = xmlSecCryptoAppKeyLoad(files, format, pwd, 
+                xmlSecCryptoAppGetDefaultPwdCallback(), (void*)files);
+    if(key == NULL) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecCryptoAppKeyLoad",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    "uri=%s", 
+                    xmlSecErrorsSafeString(files));
+        return(-1);
+    }
+    
+    if(name != NULL) {
+        ret = xmlSecKeySetName(key, BAD_CAST name);
+        if(ret < 0) {   
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        NULL,
+                        "xmlSecKeySetName",
+                        XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                        "name=%s", 
+                        xmlSecErrorsSafeString(name));
+            xmlSecKeyDestroy(key);
+            return(-1);
+        }
+    }
+
+#ifndef XMLSEC_NO_X509     
+    for(files += strlen(files) + 1; (files[0] != '\0'); files += strlen(files) + 1) {
+        ret = xmlSecCryptoAppKeyCertLoad(key, files, format);
+        if(ret < 0){
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        NULL,
+                        "xmlSecCryptoAppKeyCertLoad",
+                        XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                        "uri=%s", 
+                        xmlSecErrorsSafeString(files));
+            xmlSecKeyDestroy(key);
+            return(-1);
+        }
+    }
+#else /* XMLSEC_NO_X509 */
+    files += strlen(files) + 1;
+    if(files[0] != '\0') {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "x509",
+                    XMLSEC_ERRORS_R_DISABLED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);
+    }
+#endif /* XMLSEC_NO_X509 */        
+
+    ret = xmlSecCryptoAppDefaultKeysMngrAdoptKey(mngr, key);
+    if(ret < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecCryptoAppDefaultKeysMngrAdoptKey",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        xmlSecKeyDestroy(key);
+        return(-1);
+    }
+    
+    return(0);
+}
+
+
+int 
+xmlSecAppCryptoSimpleKeysMngrPkcs12KeyLoad(xmlSecKeysMngrPtr mngr, const char *filename, const char* pwd, const char *name) {
+    xmlSecKeyPtr key;
+    int ret;
+
+    xmlSecAssert2(mngr != NULL, -1);
+    xmlSecAssert2(filename != NULL, -1);
+
+#ifndef XMLSEC_NO_X509
+    key = xmlSecCryptoAppKeyLoad(filename, xmlSecKeyDataFormatPkcs12, pwd, 
+                    xmlSecCryptoAppGetDefaultPwdCallback(), (void*)filename);
+    if(key == NULL) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecCryptoAppKeyLoad",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    "filename=%s",
+                    xmlSecErrorsSafeString(filename));
+        return(-1);
+    }
+        
+    if(name != NULL) {
+        ret = xmlSecKeySetName(key, BAD_CAST name);
+        if(ret < 0) {   
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        NULL,
+                        "xmlSecKeySetName",
+                        XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                        "name=%s",
+                        xmlSecErrorsSafeString(name));                  
+            xmlSecKeyDestroy(key);
+            return(-1);
+        }
+    }
+    
+    ret = xmlSecCryptoAppDefaultKeysMngrAdoptKey(mngr, key);
+    if(ret < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecCryptoAppDefaultKeysMngrAdoptKey",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        xmlSecKeyDestroy(key);
+        return(-1);
+    }
+    
+    return(0);
+#else /* XMLSEC_NO_X509 */
+    xmlSecError(XMLSEC_ERRORS_HERE,
+                NULL,
+                "x509",
+                XMLSEC_ERRORS_R_DISABLED,
+                XMLSEC_ERRORS_NO_MESSAGE);
+    return(-1);
+#endif /* XMLSEC_NO_X509 */
+}
+
+int 
+xmlSecAppCryptoSimpleKeysMngrBinaryKeyLoad(xmlSecKeysMngrPtr mngr, const char* keyKlass, const char *filename, const char *name) {
+    xmlSecKeyPtr key;
+    xmlSecKeyDataId dataId;
+    int ret;
+
+    xmlSecAssert2(mngr != NULL, -1);
+    xmlSecAssert2(keyKlass != NULL, -1);
+    xmlSecAssert2(filename != NULL, -1);
+
+    /* find requested data */
+    dataId = xmlSecKeyDataIdListFindByName(xmlSecKeyDataIdsGet(), BAD_CAST keyKlass, 
+                                           xmlSecKeyDataUsageAny);
+    if(dataId == xmlSecKeyDataIdUnknown) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecKeyDataIdListFindByName",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    "name=%s",
+                    xmlSecErrorsSafeString(keyKlass));
+        return(-1);    
+    }
+
+    key = xmlSecKeyReadBinaryFile(dataId, filename);
+    if(key == NULL) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecKeyReadBinaryFile",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);    
+    }
+    
+    ret = xmlSecKeySetName(key, BAD_CAST name);
+    if(ret < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecKeySetName",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    "name=%s",
+                    xmlSecErrorsSafeString(name));
+        xmlSecKeyDestroy(key);
+        return(-1);    
+    }
+
+    /* finally add it to keys manager */    
+    ret = xmlSecCryptoAppDefaultKeysMngrAdoptKey(mngr, key);
+    if(ret < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecCryptoAppDefaultKeysMngrAdoptKey",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        xmlSecKeyDestroy(key);
+        return(-1);
+    }
+
+    return(0);
+}
+
+
+int 
+xmlSecAppCryptoSimpleKeysMngrKeyGenerate(xmlSecKeysMngrPtr mngr, const char* keyKlassAndSize, const char* name) {
+    xmlSecKeyPtr key;
+    int ret;
+
+    xmlSecAssert2(mngr != NULL, -1);
+    xmlSecAssert2(keyKlassAndSize != NULL, -1);
+    
+    key = xmlSecAppCryptoKeyGenerate(keyKlassAndSize, name, xmlSecKeyDataTypePermanent);
+    if(key == NULL) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecAppCryptoSimpleKeysMngrKeyGenerate",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    "name=%s",
+                    xmlSecErrorsSafeString(name));
+        return(-1);    
+    }    
+
+    ret = xmlSecCryptoAppDefaultKeysMngrAdoptKey(mngr, key);
+    if(ret < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecCryptoAppDefaultKeysMngrAdoptKey",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        xmlSecKeyDestroy(key);
+        return(-1);
+    }
+    return(0);
+}
+
+xmlSecKeyPtr 
+xmlSecAppCryptoKeyGenerate(const char* keyKlassAndSize, const char* name, xmlSecKeyDataType type) {
+    xmlSecKeyPtr key;
+    char* buf;
+    char* p;
+    int size;
+    int ret;
+    
+    xmlSecAssert2(keyKlassAndSize != NULL, NULL);
+
+    buf = (char*) xmlStrdup(BAD_CAST keyKlassAndSize);
+    if(buf == NULL) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    NULL,
+                    XMLSEC_ERRORS_R_STRDUP_FAILED,
+                    "name=%s",
+                    xmlSecErrorsSafeString(name));
+        return(NULL);    
+    }
+        
+    /* separate key klass and size */
+    p = strchr(buf, '-');
+    if(p == NULL) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    NULL,
+                    XMLSEC_ERRORS_R_INVALID_DATA,
+                    "key size is not specified %s", 
+                    xmlSecErrorsSafeString(buf));
+        xmlFree(buf);
+        return(NULL);
+    }
+    *(p++) = '\0';
+    size = atoi(p);
+    
+    key = xmlSecKeyGenerateByName(BAD_CAST buf, size, type);
+    if(key == NULL) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecKeyGenerate",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    "klass=%s;size=%d",
+                    xmlSecErrorsSafeString(buf), 
+                    size);
+        xmlFree(buf);
+        return(NULL);   
+    }
+    
+    ret = xmlSecKeySetName(key, BAD_CAST name);
+    if(ret < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    "xmlSecKeySetName",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    "name=\"%s\"", 
+                    xmlSecErrorsSafeString(name));
+        xmlSecKeyDestroy(key);
+        xmlFree(buf);
+        return(NULL);
+    }
+    
+    xmlFree(buf);
+    return(key);
+}