Ошибка OpenSSL: не удалось проверить первый сертификат

Question

Я пытался создать простую клиентскую/серверную эхо-приложение для ознакомления с OpenSSL. Я следил за сетевой безопасностью с OpenSSL Джоном Вигой, Мэттом Мессье, Правиром Чандрой (O'Reilly). В их примере показано, как настроить корневой центр сертификации, CA сервера, подписанный с корневым центром сертификации, а затем сертификат сервера, подписанный с CA сервера, и, наконец, сертификат клиента, подписанный с корневым центром сертификации, а затем импортировать их в программу C. Я внес небольшие изменения в программу (например, вообще не используя потоки), но большинство из них - их. Моя идея состояла в том, чтобы учиться, когда я это пробовал, но у меня возникла проблема. Когда я пытаюсь подключить два, я получаю сообщение об ошибке «Не удалось получить сертификат локального эмитента» (ошибка 20). Я также хотел бы заявить, что «предыдущая версия» работала (что означает, что они продвигаются в их примерах). Не уверен, что проблема связана с кодом, сертификатами или обоими. Моя версия OpenSSL - OpenSSL 1.0.1f 6 января 2014. (как вернули команду версии openssl)

Мои знания в этом вопросе очень мелкие на данный момент, и мне не повезло найти ответ. Я понимаю, что у меня все еще много чтения, и я это сделаю, но это проблема, которую мне нужно преодолеть. int seed_prng (int bytes) function is mine, исправление проблемы не нахождения функции seed_prng (void) во всех этих библиотеках (также одна из вещей, которые я нашел не подходящей).

Возможно, поскольку это учебное пособие 14 лет (по крайней мере), оно устарело, и я должен следовать другому? Если это так, пожалуйста, порекомендуйте учебник с высоким уровнем детализации, поскольку, по моему опыту, документация OpenSSL не очень дружелюбна.

Ниже я предоставлю все файлы, входящие в процесс (за исключением Makefile.)

Флаги, которые я использую для компиляции являются: -L/USR/Lib -lssl -lcrypto -Wall

common.h:

#include <openssl/bio.h> 
#include <openssl/err.h> 
#include <openssl/rand.h> 
#include <openssl/ssl.h> 
#include <openssl/x509v3.h> 
#include <openssl/rsa.h> 
#include <openssl/objects.h> 


#define PORT "8081" 
#define SERVER "localhost" 
#define CLIENT "localhost" 
#define int_error(msg) handle_error(__FILE__, __LINE__, msg) 

//Do not confuse with SSL_METHOD ; TLSv1_method() is also a viable option here 
#define SSL_METHOD_ SSLv23_method() 
#define SEED_PRNG_() seed_prng(30) 

#define DEFAULT_DEPTH_ 4 

#define DATA_SIZE_ 256 


void handle_error(const char *file, int lineno, const char *msg) ; 
void init_OpenSSL(void) ; 
int seed_prng(int bytes) ; 
int verify_callback(int ok, X509_STORE_CTX *store) ; 
long post_connection_check(SSL *ssl, char *host) ; 

common.c:

#include "common.h" 

void handle_error(const char *file, int lineno, const char *msg) 
{ 
    fprintf(stderr, "** %s:%i %s\n", file, lineno, msg); 
    ERR_print_errors_fp(stderr); 
    exit(-1); 
} 
void init_OpenSSL(void) 
{ 
    if (!SSL_library_init()) 
    { 
     fprintf(stderr, "** OpenSSL initialization failed!\n"); 
     exit(-1); 
    } 
    SSL_load_error_strings(); 
} 

//Not sure if this is good idea! Have to do some research 
int seed_prng(int bytes) 
{ 
    if (!RAND_load_file("/dev/urandom", bytes)) 
    { 
     return 0; 
    } 

    return 1; 
} 

int verify_callback(int ok, X509_STORE_CTX *store) 
{ 
    char data[DATA_SIZE_]; 
    if (!ok) 
    { 
     X509 *cert = X509_STORE_CTX_get_current_cert(store); 
     int depth = X509_STORE_CTX_get_error_depth(store); 
     int err = X509_STORE_CTX_get_error(store); 
     fprintf(stderr, "-Error with certificate at depth: %i\n", depth); 
     X509_NAME_oneline(X509_get_issuer_name(cert), data, 256); 
     fprintf(stderr, " issuer = %s\n", data); 
     X509_NAME_oneline(X509_get_subject_name(cert), data, 256); 
     fprintf(stderr, " subject = %s\n", data); 
     fprintf(stderr, " err %i:%s\n", err, 
     X509_verify_cert_error_string(err)); 
    } 
    return ok; 
} 

long post_connection_check(SSL *ssl, char *host) 
{ 
    X509 *cert; 
    X509_NAME *subj; 
    char data[DATA_SIZE_]; 
    int extcount; 
    int ok = 0; 

    if (!(cert = SSL_get_peer_certificate(ssl)) || !host) 
    { 
     if (cert) 
     { 
      X509_free(cert); 
     } 
     return X509_V_ERR_APPLICATION_VERIFICATION; 
    } 
    if ((extcount = X509_get_ext_count(cert)) > 0) 
    { 
     int i; 
     for (i = 0; i < extcount; i++) 
     { 
      const char *extstr; 
      X509_EXTENSION *ext; 
      ext = X509_get_ext(cert, i); 
      extstr = OBJ_nid2sn(OBJ_obj2nid(X509_EXTENSION_get_object(ext))); 
      if (!strcmp(extstr, "subjectAltName")) 
      { 
       int j; 
       unsigned char *data; 
       STACK_OF(CONF_VALUE) *val; 
       CONF_VALUE *nval; 
       const X509V3_EXT_METHOD *meth; 
       if (!(meth = X509V3_EXT_get(ext))) 
       { 
        break; 
       } 
       data = ext->value->data; 
       val = meth->i2v(meth,(meth->d2i(NULL, (const unsigned char **)(&data), ext->value->length)), NULL); 
       for (j = 0; j < sk_CONF_VALUE_num(val); j++) 
       { 
        nval = sk_CONF_VALUE_value(val, j); 
        if (!strcmp(nval->name, "DNS") && !strcmp(nval->value, host)) 
        { 
         ok = 1; 
         break; 
        } 
       } 
      } 
      if (ok) 
      { 
       break; 
      } 
     } 
    } 
    if (!ok && (subj = X509_get_subject_name(cert)) && X509_NAME_get_text_by_NID(subj, NID_commonName, data, DATA_SIZE_) > 0) 
    { 
     data[DEFAULT_DEPTH_ - 1] = 0; 
     if (strcasecmp(data, host) != 0) 
     { 
      if (cert) 
      { 
       X509_free(cert); 
      } 
      return X509_V_ERR_APPLICATION_VERIFICATION; 
     } 
    } 
    X509_free(cert); 
    return SSL_get_verify_result(ssl); 
} 

server.c:

#include "common.h" 


#define BUF_SIZE_ 80 

#define CERTFILE "certificates/serverNOKEY.pem" 
#define CAFILE "certificates/rootcert.pem" 
#define CADIR NULL 


SSL_CTX *setup_server_ctx(void) 
{ 
    SSL_CTX *ctx; 

    //This specifies that either SSL or TLS can be used 
    //Later, we will "filter" out SSLv2 
    ctx = SSL_CTX_new(SSLv23_method()); 

    //These two functions are used to load trusted CAs 
    if (SSL_CTX_load_verify_locations(ctx, CAFILE, CADIR) != 1) 
    { 
     int_error("Error loading CA file and/or directory"); 
    } 
    if (SSL_CTX_set_default_verify_paths(ctx) != 1) 
    { 
     int_error("Error loading default CA file and/or directory"); 
    } 

    //This loads a certificate from a file 
    if (SSL_CTX_use_certificate_chain_file(ctx, CERTFILE) != 1) 
    { 
      int_error("Error loading certificate from file"); 
    } 
    //This loads a private key (in our code, from the same file but I think that it is not necessary) 
    if (SSL_CTX_use_PrivateKey_file(ctx, CERTFILE, SSL_FILETYPE_PEM) != 1) 
    { 
      int_error("Error loading private key from file"); 
    } 
    SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT, verify_callback); 
    SSL_CTX_set_verify_depth(ctx, DEFAULT_DEPTH_); 

    return ctx; 
} 

int do_server_loop(SSL *ssl) 
{ 
    int err, nread; 
    char buf[BUF_SIZE_]; 
    //I think that this reading should be redone 'cause there's something wrong 
    do 
    { 
     for (nread = 0; nread < sizeof(buf) - 1; nread += err) 
     { 
      err = SSL_read(ssl, buf + nread, sizeof(buf) - nread); 
      printf("read %d bytes\n", err); 
      if (err <= 0) 
      { 
       break; 
      } 
     } 
     fwrite(buf, sizeof(char), nread, stdout); 

    } while (err > 0); 
    return (SSL_get_shutdown(ssl) & SSL_RECEIVED_SHUTDOWN) ? 1 : 0; 
} 


void server_part(SSL *ssl) 
{ 
    long err; 
    //accepting connection from ssl object (structure) 
    if (SSL_accept(ssl) <= 0) 
    { 
     int_error("Error accepting SSL connection"); 
    } 
    if ((err = post_connection_check(ssl, CLIENT)) != X509_V_OK) 
    { 
     fprintf(stderr, "-Error: peer certificate: %s\n", 
     X509_verify_cert_error_string(err)); 
     int_error("Error checking SSL object after connection"); 
    } 
    fprintf(stderr, "SSL Connection opened\n"); 
    //As I figured, SSL_shutdown is a clean way to go but SSL_clear 
    //will force the closing of the communication if it wasn't closed cleanly 
    if (do_server_loop(ssl)) 
    { 
     //See this https://www.openssl.org/docs/manmaster/ssl/SSL_shutdown.html 
     SSL_shutdown(ssl); 
    } 
    else 
    { 
     // https://www.openssl.org/docs/manmaster/ssl/SSL_clear.html 
     SSL_clear(ssl); 
    } 
    fprintf(stderr, "SSL Connection closed\n"); 
    SSL_free(ssl); 
} 


int main(int argc, char *argv[]) 
{ 
    BIO *acc, *client; 
    SSL *ssl; 
    SSL_CTX *ctx; 

    init_OpenSSL(); 

    //This is my function, gotta investigate it and see what should be there (maybe I got it right?) 
    SEED_PRNG_(); 


    ctx = setup_server_ctx(); 
    acc = BIO_new_accept(PORT); 
    if (!acc) 
    { 
     int_error("Error creating server socket"); 
    } 
    if (BIO_do_accept(acc) <= 0) 
    { 
     int_error("Error binding server socket"); 
    } 
    for (;;) 
    { 
     if (BIO_do_accept(acc) <= 0) 
     { 
      int_error("Error accepting connection"); 
     } 
     client = BIO_pop(acc); 
     if (!(ssl = SSL_new(ctx))) 
     { 
      int_error("Error creating SSL context"); 
     } 
     SSL_set_bio(ssl, client, client); 
     server_part(ssl); 
    } 
    SSL_CTX_free(ctx); 
    BIO_free(acc); 
    return 0; 
} 

client.c:

#include "common.h" 

#define BUF_SIZE_ 80 

#define CERTFILE "certificates/clientNOKEY.pem" 
#define CAFILE "certificates/rootcert.pem" 
#define CADIR NULL 

SSL_CTX *setup_client_ctx(void) 
{ 
    SSL_CTX *ctx; 
    ctx = SSL_CTX_new(SSL_METHOD_); 

    if (SSL_CTX_load_verify_locations(ctx, CAFILE, CADIR) != 1) 
    { 
     int_error("Error loading CA file and/or directory"); 
    } 
    if (SSL_CTX_set_default_verify_paths(ctx) != 1) 
    { 
     int_error("Error loading default CA file and/or directory"); 
    } 
    if (SSL_CTX_use_certificate_chain_file(ctx, CERTFILE) != 1) 
    { 
     int_error("Error loading certificate from file"); 
    } 
    if (SSL_CTX_use_PrivateKey_file(ctx, CERTFILE, SSL_FILETYPE_PEM) != 1) 
    { 
     int_error("Error loading private key from file"); 
    } 
    SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, verify_callback); 
    SSL_CTX_set_verify_depth(ctx, DEFAULT_DEPTH_); 

    return ctx; 
} 

int do_client_loop(SSL *ssl) 
{ 
    int err, nwritten; 
    char buf[BUF_SIZE_]; 
    for (;;) 
    { 
     if (!fgets(buf, sizeof(buf), stdin)) 
     { 
      break; 
     } 
     //printf("ucitao: %s\n", buf); 
     for (nwritten = 0; nwritten < sizeof(buf); nwritten += err) 
     { 

      err = SSL_write(ssl, buf + nwritten, strlen(buf) - nwritten); 
      if (err <= 0) 
      { 
       return 0; 
      } 
      else 
      { 
       printf("Sent: %s\n", buf); 
      } 
     } 

    } 
    return 1; 
} 

int main(int argc, char *argv[]) 
{ 
    BIO *conn; 
    SSL *ssl; 
    SSL_CTX *ctx; 
    long err; 

    init_OpenSSL(); 
    SEED_PRNG_(); 

    ctx = setup_client_ctx(); 

    conn = BIO_new_connect(SERVER ":" PORT); 
    if (!conn) 
    { 
     int_error("Error creating connection BIO"); 
    } 
    if (BIO_do_connect(conn) <= 0) 
    { 
     int_error("Error connecting to remote machine"); 
    } 
    if (!(ssl = SSL_new(ctx))) 
    int_error("Error creating an SSL context"); 
    SSL_set_bio(ssl, conn, conn); 
    if (SSL_connect(ssl) <= 0) 
    { 
     int_error("Error connecting SSL object"); 
    } 
    if ((err = post_connection_check(ssl, SERVER)) != X509_V_OK) 
    { 
     fprintf(stderr, "-Error: peer certificate: %s\n", 
     X509_verify_cert_error_string(err)); 
     int_error("Error checking SSL object after connection"); 
    } 
    fprintf(stderr, "SSL Connection opened\n"); 
    if (do_client_loop(ssl)) 
    { 
     SSL_shutdown(ssl); 
    } 
    else 
    { 
     SSL_clear(ssl); 
    } 
    fprintf(stderr, "SSL Connection closed\n"); 
    SSL_free(ssl); 
    SSL_CTX_free(ctx); 
    return 0; 
} 

сценарий, я использовал для создания центров сертификации, сертификаты и подписать их:

#! /bin/bash 

echo "Begin" 

#the line below ensures that the script finishes after an unsuccessful command, not trying to execute any next command, 
#since it's the assumption that every previous command was successful 
set -e 

echo "Creating the root CA" 
openssl req -newkey rsa:1024 -sha1 -keyout rootkey.pem -out rootreq.pem 
openssl x509 -req -in rootreq.pem -sha1 -extfile myopenssl.cnf -extensions v3_ca -signkey rootkey.pem -out rootcert.pem 
cat rootcert.pem rootkey.pem > root.pem 
openssl x509 -subject -issuer -noout -in root.pem 

echo "Creating the server CA and signing it with the root CA" 
openssl req -newkey rsa:1024 -sha1 -keyout serverCAkey.pem -out serverCAreq.pem 
openssl x509 -req -in serverCAreq.pem -sha1 -extfile myopenssl.cnf -extensions v3_ca -CA root.pem -CAkey root.pem -CAcreateserial -out serverCAcert.pem 
cat serverCAcert.pem serverCAkey.pem rootcert.pem > serverCA.pem 
openssl x509 -subject -issuer -noout -in serverCA.pem 

echo "Creating the server\'s certificate and signing it with the server CA" 
openssl req -newkey rsa:1024 -sha1 -keyout serverkey.pem -out serverreq.pem 
openssl x509 -req -in serverreq.pem -sha1 -extfile myopenssl.cnf -extensions usr_cert -CA serverCA.pem -CAkey serverCA.pem -CAcreateserial -out servercert.pem 
cat servercert.pem serverkey.pem serverCAcert.pem rootcert.pem > server.pem 
openssl x509 -subject -issuer -noout -in server.pem 

echo "Creating the client certificate and signing it with the root CA" 
openssl req -newkey rsa:1024 -sha1 -keyout clientkey.pem -out clientreq.pem 
openssl x509 -req -in clientreq.pem -sha1 -extfile myopenssl.cnf -extensions usr_cert -CA root.pem -CAkey root.pem -CAcreateserial -out clientcert.pem 
cat clientcert.pem clientkey.pem rootcert.pem > client.pem 
openssl x509 -subject -issuer -noout -in client.pem 

echo "creating dh512.pem and dh1024.pem" 
openssl dhparam -check -text -5 512 -out dh512.pem 
openssl dhparam -check -text -5 1024 -out dh1024.pem 

echo "Making new keys which do not require passkey" 

echo "Creating no passkey server key" 
openssl rsa -in server.pem -out serverNOKEY.pem 
openssl x509 -in server.pem >>serverNOKEY.pem 
echo "serverNOKEY.pem created" 

echo "Creating no passkey client key" 
openssl rsa -in client.pem -out clientNOKEY.pem 
openssl x509 -in client.pem >>clientNOKEY.pem 
echo "clientNOKEY.pem created" 

echo "Done! Success!" 

Answer 1

я столкнулся с аналогичной проблемой, когда я настраивал SSL Communications между приложениями Java. Чтобы определить, может ли сама проблема с кодом или выдавать сертификат, вы можете выполнить команду openssl ниже. Если сертификат не проверяется, это означает, что есть проблемы с проверкой сертификатов с использованием корневого центра сертификации.

Verify a certificate

openssl verify certificate_name

Reference.

Кроме того, поскольку вы работаете над самозаверяющим сертификатом, вы можете отключить проверку сертификатов в своем коде и продолжить. В производственной среде, когда сертификаты подписываются Центром сертификации (CA), такие ошибки менее вероятны.