Question

Im trying to make a ssl client that connects to ssl IRC Servers but it’s giving me this error:

26460:error:140A90A1:SSL routines:SSL_CTX_new:library has no ciphers:ssl_lib.c:1535:

code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef WIN32
#   ifndef WIN32_LEAN_AND_MEAN
#       define WIN32_LEAN_AND_MEAN
#   endif
#endif
#if defined(_WIN32)
#   include <winsock2.h>
#   include <windows.h>
#   include <process.h>
#   include <io.h>
#   include <direct.h>
#else
#   include <sys/types.h>
#   include <sys/socket.h>
#   include <netinet/in.h>
#   include <netdb.h>
#   include <sys/timeb.h>
#   include <unistd.h>
#   include <stdbool.h>
#   include <fcntl.h>
#endif
/* ssl */
#include <openssl/ssl.h>
#include <openssl/err.h>
/**********************/
#include <stddef.h>
#include <stdint.h>
#include <stdarg.h>
#include <errno.h>
#include <ctype.h>
#include <assert.h>
#ifndef SOCKET_ERROR
#   define SOCKET_ERROR -1
#endif
#ifndef SOCKADDR
#   define SOCKADDR struct sockaddr
#endif
#ifndef SOCKADDR_IN
#   define SOCKADDR_IN struct sockaddr_in
#endif
#if defined(_WIN32) && !defined(bool)
#   define bool uint32_t
#   define true 1
#   define false 0
#endif

const char *g_host;
int *g_port;

typedef struct {
    SSL_CTX *ctx;
    SSL *ssl;
    SOCKADDR_IN serv_addr;
    int fd;
} Socket;

void *MyMalloc(uint32_t);
void MyFree(void *);
Socket* setup_socket();
bool connect_socket(Socket *);

static void
out_of_memory()
{
    fprintf(stderr, "Virtual memory exhausted: cannot allocate memory\n");
    exit(-1);
}

void*
MyMalloc(size)
    uint32_t size;
{
    void *ret;
    if (!size) {
        fprintf(stderr, "MyMalloc(): Error on allocating memory, size = %u\n", size);
        return NULL;
    }

    ret = calloc(1, size);
    if (!ret)
        out_of_memory();

    return ret;
}

void
MyFree(p)
    void *p;
{
    if (p)
        free(p);
}

static void
create_ctx(socket)
    Socket* socket;
{
    SSL_METHOD *method;
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();

    method = SSLv23_server_method();

    socket->ctx = SSL_CTX_new(method);
    if (!socket->ctx) {
        ERR_print_errors_fp(stderr);
        exit(-1);
    }
}

Socket*
setup_socket()
{
    Socket* sock;
    int fd;
    SSL* ssl;
#ifdef _WIN32
    WSADATA wsadata;
    if (WSAStartup(MAKEWORD(2, 0), &wsadata) != 0)
        return NULL;
#endif
    sock = (Socket *)MyMalloc(sizeof(*sock));
    fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    sock->fd = fd;
    create_ctx(sock);
    if (!sock->ctx)
        return NULL;
    ssl = SSL_new(sock->ctx);
    sock->ssl = ssl;
}

bool
connect_socket(sock)
    Socket* sock;
{
    if (!sock || !sock->fd)
        return false;
#ifdef _WIN32
    LPHOSTENT host;
#else
    struct hostent* host;
#endif
    SOCKADDR_IN serv_addr;

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(*g_port);
    host = gethostbyname(g_host);
    if (!host) {
        fprintf(stderr, "Cannot resolve %s: %s\n", g_host, strerror(errno));
        return false;
    }

#ifdef _WIN32
    serv_addr.sin_addr = *((LPIN_ADDR)*host->h_addr_list);
#else
    serv_addr.sin_addr = *((struct in_addr*)host->h_addr);
#endif
    sock->serv_addr = serv_addr;
    if (connect(sock->fd,(SOCKADDR *)&sock->serv_addr,sizeof(sock->serv_addr)) != SOCKET_ERROR){
        if (!SSL_set_fd(sock->ssl,sock->fd)){
            ERR_print_errors_fp(stderr);
            exit(-1);
        }
        if (SSL_connect(sock->ssl) != 1){
            ERR_print_errors_fp(stderr);
            exit(-1);
        }
        return true;
    }
    return false;
}

int main(argc, argv)
    int argc;
    char **argv;
{
    const char *__host;
    int __port;
    Socket* sock;
    char buffer[1024];
    int p;
    __host  = (const char *)strdup("irc.mozilla.org");
    __port = 6697;
    if (argc>1){
        /* skip program name */
        ++argv;
        while (*argv){
            if (strcmp(*argv,"--host") == 0 || !strcmp(*argv,"-host")){
                ++argv;
                if (!*argv){
                    fprintf(stderr,"Failure\n");
                    return -1;
                }
                __host = (const char *)*argv;
            } else if (strcmp(*argv,"--port") == 0 || !strcmp(*argv,"-port")){
                ++argv;
                if (!*argv){
                    fprintf(stderr,"Failure\n");
                    return -1;
                }
                __port = atoi((const char *)*argv);
            }
        }
    }
    if (!__host || *__host == '\0' || __port < 6667){
        fprintf(stderr,"Failure\n");
        return -1;
    }

    g_port = &__port;
    g_host = __host;
    if (!(sock = setup_socket())){
        fprintf(stderr,"Failed to setup socket\n");
        return -1;
    }

    if (!connect_socket(sock)){
        fprintf(stderr,"Failed to connect\n");
        return -1;
    }

    while (1){
        p = SSL_read(sock->ssl,buffer,sizeof(buffer));
        if (p<0){break;}
        if (p<sizeof(buffer)) {break;}
        fprintf(stderr,"Received:%s\n",buffer);
    }
    return 0;
}

Answer 1

this:

SSLv23_server_method();

to:

SSLv23_client_method();