Changeset 40000


Ignore:
Timestamp:
2014-03-21T16:55:23+01:00 (4 years ago)
Author:
nbd
Message:

px5g: rename the old package to px5g-standalone, add a new one that links against polarssl

Signed-off-by: Felix Fietkau <nbd@…>

Location:
trunk/package/utils
Files:
4 added
1 deleted
1 edited
20 copied

Legend:

Unmodified
Added
Removed
  • trunk/package/utils/px5g-standalone/Makefile

    r39999 r40000  
    1515include $(INCLUDE_DIR)/package.mk 
    1616 
    17 define Package/px5g 
     17define Package/px5g-standalone 
    1818  SECTION:=utils 
    1919  CATEGORY:=Utilities 
    20   TITLE:=Standalone X.509 certificate generator 
     20  TITLE:=Standalone X.509 certificate generator (standalone version) 
    2121  MAINTAINER:=Jo-Philipp Wich <xm@subsignal.org> 
    2222endef 
    2323 
    24 define Package/px5g/description 
     24define Package/px5g-standalone/description 
    2525 Px5g is a tiny standalone X.509 certificate generator. 
    2626 It suitable to create key files and certificates in DER 
     
    3333endef 
    3434 
    35 define Package/px5g/install 
     35define Package/px5g-standalone/install 
    3636        $(INSTALL_DIR) $(1)/usr/sbin 
    3737        $(INSTALL_BIN) $(PKG_BUILD_DIR)/px5g $(1)/usr/sbin/px5g 
    3838endef 
    3939 
    40 $(eval $(call BuildPackage,px5g)) 
     40$(eval $(call BuildPackage,px5g-standalone)) 
  • trunk/package/utils/px5g/Makefile

    r37007 r40000  
    1111PKG_RELEASE:=1 
    1212 
    13 PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME) 
     13PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME)-$(BUILD_VARIANT) 
     14PKG_USE_MIPS16:=0 
    1415 
    1516include $(INCLUDE_DIR)/package.mk 
     
    1819  SECTION:=utils 
    1920  CATEGORY:=Utilities 
    20   TITLE:=Standalone X.509 certificate generator 
     21  TITLE:=X.509 certificate generator (using PolarSSL) 
    2122  MAINTAINER:=Jo-Philipp Wich <xm@subsignal.org> 
     23  DEPENDS:=+libpolarssl 
    2224endef 
    2325 
     
    3032define Build/Prepare 
    3133        mkdir -p $(PKG_BUILD_DIR) 
    32         $(CP) ./src/* $(PKG_BUILD_DIR)/ 
     34endef 
     35 
     36define Build/Compile 
     37        $(TARGET_CC) $(TARGET_CFLAGS) -o $(PKG_BUILD_DIR)/px5g px5g.c -lpolarssl 
    3338endef 
    3439 
  • trunk/package/utils/px5g/px5g.c

    r39999 r40000  
    33 * 
    44 *   Copyright (C) 2009 Steven Barth <steven@midlink.org> 
     5 *   Copyright (C) 2014 Felix Fietkau <nbd@openwrt.org> 
    56 * 
    67 *  This library is free software; you can redistribute it and/or 
     
    1920 */ 
    2021 
     22#include <sys/types.h> 
     23 
    2124#include <stdio.h> 
    2225#include <stdlib.h> 
     
    2427#include <time.h> 
    2528#include <limits.h> 
    26 #include "polarssl/havege.h" 
    27 #include "polarssl/bignum.h" 
    28 #include "polarssl/x509.h" 
    29 #include "polarssl/rsa.h" 
    30  
    31 #define PX5G_VERSION "0.1" 
     29#include <unistd.h> 
     30#include <fcntl.h> 
     31#include <stdbool.h> 
     32 
     33#include <polarssl/bignum.h> 
     34#include <polarssl/x509_crt.h> 
     35#include <polarssl/rsa.h> 
     36 
     37#define PX5G_VERSION "0.2" 
    3238#define PX5G_COPY "Copyright (c) 2009 Steven Barth <steven@midlink.org>" 
    3339#define PX5G_LICENSE "Licensed under the GNU Lesser General Public License v2.1" 
    3440 
    35 int rsakey(char **arg) { 
    36         havege_state hs; 
    37         rsa_context rsa; 
    38  
     41static int urandom_fd; 
     42static char buf[16384]; 
     43 
     44static int _urandom(void *ctx, unsigned char *out, size_t len) 
     45{ 
     46        read(urandom_fd, out, len); 
     47        return 0; 
     48} 
     49 
     50static void write_file(const char *path, int len, bool pem) 
     51{ 
     52        FILE *f = stdout; 
     53        const char *buf_start = buf; 
     54 
     55        if (!pem) 
     56                buf_start += sizeof(buf) - len; 
     57 
     58        if (!len) { 
     59                fprintf(stderr, "No data to write\n"); 
     60                exit(1); 
     61        } 
     62 
     63        if (!f) { 
     64                fprintf(stderr, "error: I/O error\n"); 
     65                exit(1); 
     66        } 
     67 
     68        if (path) 
     69                f = fopen(path, "w"); 
     70 
     71        fwrite(buf_start, 1, len, f); 
     72        fclose(f); 
     73} 
     74 
     75static void write_key(pk_context *key, const char *path, bool pem) 
     76{ 
     77        int len = 0; 
     78 
     79        if (pem) { 
     80                if (pk_write_key_pem(key, (void *) buf, sizeof(buf)) == 0) 
     81                        len = strlen(buf); 
     82        } else { 
     83                len = pk_write_key_der(key, (void *) buf, sizeof(buf)); 
     84                if (len < 0) 
     85                        len = 0; 
     86        } 
     87 
     88        write_file(path, len, pem); 
     89} 
     90 
     91static void gen_key(pk_context *key, int ksize, int exp, bool pem) 
     92{ 
     93        pk_init(key); 
     94        pk_init_ctx(key, pk_info_from_type(POLARSSL_PK_RSA)); 
     95        fprintf(stderr, "Generating RSA private key, %i bit long modulus\n", ksize); 
     96        if (rsa_gen_key(pk_rsa(*key), _urandom, NULL, ksize, exp)) { 
     97                fprintf(stderr, "error: key generation failed\n"); 
     98                exit(1); 
     99        } 
     100} 
     101 
     102int rsakey(char **arg) 
     103{ 
     104        pk_context key; 
    39105        unsigned int ksize = 512; 
    40106        int exp = 65537; 
    41107        char *path = NULL; 
    42         int flag = X509_OUTPUT_PEM; 
     108        bool pem = true; 
    43109 
    44110        while (*arg && **arg == '-') { 
     
    49115                        exp = 3; 
    50116                } else if (!strcmp(*arg, "-der")) { 
    51                         flag = X509_OUTPUT_DER; 
     117                        pem = false; 
    52118                } 
    53119                arg++; 
    54120        } 
    55121 
    56         if (*arg) { 
     122        if (*arg) 
    57123                ksize = (unsigned int)atoi(*arg); 
    58         } 
    59  
    60         havege_init(&hs); 
    61         rsa_init(&rsa, RSA_PKCS_V15, 0, havege_rand, &hs); 
    62  
    63         fprintf(stderr, "Generating RSA private key, %i bit long modulus\n", ksize); 
    64         if (rsa_gen_key(&rsa, ksize, exp)) { 
    65                 fprintf(stderr, "error: key generation failed\n"); 
    66                 return 1; 
    67         } 
    68  
    69         if (x509write_keyfile(&rsa, path, flag)) { 
    70                 fprintf(stderr, "error: I/O error\n"); 
    71                 return 1; 
    72         } 
    73  
    74         rsa_free(&rsa); 
     124 
     125        gen_key(&key, ksize, exp, pem); 
     126        write_key(&key, path, pem); 
     127 
     128        pk_free(&key); 
     129 
    75130        return 0; 
    76131} 
    77132 
    78 int selfsigned(char **arg) { 
    79         havege_state hs; 
    80         rsa_context rsa; 
    81         x509_node node; 
     133int selfsigned(char **arg) 
     134{ 
     135        pk_context key; 
     136        x509write_cert cert; 
     137        mpi serial; 
    82138 
    83139        char *subject = ""; 
     
    86142        unsigned int days = 30; 
    87143        char *keypath = NULL, *certpath = NULL; 
    88         int flag = X509_OUTPUT_PEM; 
     144        bool pem = true; 
    89145        time_t from = time(NULL), to; 
    90146        char fstr[20], tstr[20]; 
     147        int len; 
    91148 
    92149        while (*arg && **arg == '-') { 
    93150                if (!strcmp(*arg, "-der")) { 
    94                         flag = X509_OUTPUT_DER; 
     151                        pem = false; 
    95152                } else if (!strcmp(*arg, "-newkey") && arg[1]) { 
    96153                        if (strncmp(arg[1], "rsa:", 4)) { 
     
    140197        } 
    141198 
    142         havege_init(&hs); 
    143         rsa_init(&rsa, RSA_PKCS_V15, 0, havege_rand, &hs); 
    144         x509write_init_node(&node); 
    145         fprintf(stderr, "Generating RSA private key, %i bit long modulus\n", ksize); 
    146         if (rsa_gen_key(&rsa, ksize, exp)) { 
    147                 fprintf(stderr, "error: key generation failed\n"); 
    148                 return 1; 
    149         } 
    150  
    151         if (keypath) { 
    152                 if (x509write_keyfile(&rsa, keypath, flag)) { 
    153                         fprintf(stderr, "error: I/O error\n"); 
    154                         return 1; 
    155                 } 
    156         } 
     199        gen_key(&key, ksize, exp, pem); 
     200 
     201        if (keypath) 
     202                write_key(&key, keypath, pem); 
    157203 
    158204        from = (from < 1000000000) ? 1000000000 : from; 
    159         strftime(fstr, sizeof(fstr), "%F %H:%M:%S", gmtime(&from)); 
     205        strftime(fstr, sizeof(fstr), "%Y%m%d%H%M%S", gmtime(&from)); 
    160206        to = from + 60 * 60 * 24 * days; 
    161207        if (to < from) 
    162208                to = INT_MAX; 
    163         strftime(tstr, sizeof(tstr), "%F %H:%M:%S", gmtime(&to)); 
    164  
    165         x509_raw cert; 
    166         x509write_init_raw(&cert); 
    167         x509write_add_pubkey(&cert, &rsa); 
    168         x509write_add_subject(&cert, (unsigned char*)subject); 
    169         x509write_add_validity(&cert, (unsigned char*)fstr, (unsigned char*)tstr); 
     209        strftime(tstr, sizeof(tstr), "%Y%m%d%H%M%S", gmtime(&to)); 
     210 
    170211        fprintf(stderr, "Generating selfsigned certificate with subject '%s'" 
    171212                        " and validity %s-%s\n", subject, fstr, tstr); 
    172         if (x509write_create_selfsign(&cert, &rsa)) { 
    173                 fprintf(stderr, "error: certificate generation failed\n"); 
    174         } 
    175  
    176         if (x509write_crtfile(&cert, (unsigned char*)certpath, flag)) { 
    177                 fprintf(stderr, "error: I/O error\n"); 
    178                 return 1; 
    179         } 
    180  
    181         x509write_free_raw(&cert); 
    182         rsa_free(&rsa); 
     213 
     214        x509write_crt_init(&cert); 
     215        x509write_crt_set_md_alg(&cert, POLARSSL_MD_SHA1); 
     216        x509write_crt_set_issuer_key(&cert, &key); 
     217        x509write_crt_set_subject_key(&cert, &key); 
     218        x509write_crt_set_subject_name(&cert, subject); 
     219        x509write_crt_set_issuer_name(&cert, subject); 
     220        x509write_crt_set_validity(&cert, fstr, tstr); 
     221        x509write_crt_set_basic_constraints(&cert, 0, -1); 
     222        x509write_crt_set_subject_key_identifier(&cert); 
     223        x509write_crt_set_authority_key_identifier(&cert); 
     224 
     225        mpi_init(&serial); 
     226        mpi_read_string(&serial, 10, "1"); 
     227        x509write_crt_set_serial(&cert, &serial); 
     228 
     229        if (pem) { 
     230                if (x509write_crt_pem(&cert, (void *) buf, sizeof(buf), _urandom, NULL) < 0) { 
     231                        fprintf(stderr, "Failed to generate certificate\n"); 
     232                        return 1; 
     233                } 
     234 
     235                len = strlen(buf); 
     236        } else { 
     237                len = x509write_crt_der(&cert, (void *) buf, sizeof(buf), _urandom, NULL); 
     238                if (len < 0) { 
     239                        fprintf(stderr, "Failed to generate certificate: %d\n", len); 
     240                        return 1; 
     241                } 
     242        } 
     243        write_file(certpath, len, pem); 
     244 
     245        x509write_crt_free(&cert); 
     246        mpi_free(&serial); 
     247        pk_free(&key); 
     248 
    183249        return 0; 
    184250} 
    185251 
    186 int main(int argc, char *argv[]) { 
     252int main(int argc, char *argv[]) 
     253{ 
     254        urandom_fd = open("/dev/urandom", O_RDONLY); 
     255 
    187256        if (!argv[1]) { 
    188257                //Usage 
Note: See TracChangeset for help on using the changeset viewer.