Exemple #1
0
result_t X509Cert::dump(v8::Local<v8::Array> &retVal)
{
    if (m_root)
        return CHECK_ERROR(CALL_E_INVALID_CALL);

    retVal = v8::Array::New(isolate);

    const x509_crt *pCert = &m_crt;
    int ret, n = 0;
    std::string buf;
    size_t olen;

    while (pCert)
    {
        if (pCert->raw.len > 0)
        {
            buf.resize(pCert->raw.len * 2 + 64);
            ret = pem_write_buffer(PEM_BEGIN_CRT, PEM_END_CRT,
                                   pCert->raw.p, pCert->raw.len,
                                   (unsigned char *)&buf[0], buf.length(), &olen);
            if (ret != 0)
                return CHECK_ERROR(_ssl::setError(ret));

            retVal->Set(n ++, v8::String::NewFromUtf8(isolate, buf.c_str(),
                        v8::String::kNormalString, (int) olen - 1));
        }
        pCert = pCert->next;
    }

    return 0;
}
int pk_write_pubkey_pem( pk_context *key, unsigned char *buf, size_t size )
{
    int ret;
    unsigned char output_buf[1280000];
    size_t olen = 0;

    if( ( ret = pk_write_pubkey_der( key, output_buf,
                                     sizeof(output_buf) ) ) < 0 )
    {
        return( ret );
    }

    if( ( ret = pem_write_buffer( PEM_BEGIN_PUBLIC_KEY, PEM_END_PUBLIC_KEY,
                                  output_buf + sizeof(output_buf) - ret,
                                  ret, buf, size, &olen ) ) != 0 )
    {
        return( ret );
    }

    return( 0 );
}
Exemple #3
0
result_t X509Req::exportPem(std::string &retVal)
{
    if (m_csr.raw.len == 0)
        return CHECK_ERROR(CALL_E_INVALID_CALL);

    std::string buf;
    size_t olen;
    int ret;

    buf.resize(m_csr.raw.len * 2 + 64);
    ret = pem_write_buffer(PEM_BEGIN_CSR, PEM_END_CSR,
                           m_csr.raw.p, m_csr.raw.len,
                           (unsigned char *)&buf[0], buf.length(), &olen);
    if (ret != 0)
        return CHECK_ERROR(_ssl::setError(ret));

    buf.resize(olen - 1);
    retVal = buf;

    return 0;
}
Exemple #4
0
int x509write_csr_pem( x509write_csr *ctx, unsigned char *buf, size_t size,
                       int (*f_rng)(void *, unsigned char *, size_t),
                       void *p_rng )
{
    int ret;
    unsigned char output_buf[4096];
    size_t olen = 0;

    if( ( ret = x509write_csr_der( ctx, output_buf, sizeof(output_buf),
                                   f_rng, p_rng ) ) < 0 )
    {
        return( ret );
    }

    if( ( ret = pem_write_buffer( PEM_BEGIN_CSR, PEM_END_CSR,
                                  output_buf + sizeof(output_buf) - ret,
                                  ret, buf, size, &olen ) ) != 0 )
    {
        return( ret );
    }

    return( 0 );
}
Exemple #5
0
int pk_write_key_pem( pk_context *key, unsigned char *buf, size_t size )
{
    int ret;
    unsigned char output_buf[8192];
    const char *begin, *end;
    size_t olen = 0;

    if( ( ret = pk_write_key_der( key, output_buf, sizeof(output_buf) ) ) < 0 )
        return( ret );

#if defined(POLARSSL_RSA_C)
    if( pk_get_type( key ) == POLARSSL_PK_RSA )
    {
        begin = PEM_BEGIN_PRIVATE_KEY_RSA;
        end = PEM_END_PRIVATE_KEY_RSA;
    }
    else
#endif
#if defined(POLARSSL_ECP_C)
    if( pk_get_type( key ) == POLARSSL_PK_ECKEY )
    {
        begin = PEM_BEGIN_PRIVATE_KEY_EC;
        end = PEM_END_PRIVATE_KEY_EC;
    }
    else
#endif
        return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE );

    if( ( ret = pem_write_buffer( begin, end,
                                  output_buf + sizeof(output_buf) - ret,
                                  ret, buf, size, &olen ) ) != 0 )
    {
        return( ret );
    }

    return( 0 );
}
int pk_write_key_pem( pk_context *key, unsigned char *buf, size_t size )
{
    int ret;
    unsigned char output_buf[1280000];
    const char *begin, *end;
    size_t olen = 0;

    if( ( ret = pk_write_key_der( key, output_buf, sizeof(output_buf) ) ) < 0 )
        return( ret );

#if defined(POLARSSL_RSA_C)
    if( pk_get_type( key ) == POLARSSL_PK_RSA )
    {
        begin = PEM_BEGIN_PRIVATE_KEY_RSA;
        end = PEM_END_PRIVATE_KEY_RSA;
    }
    else
#endif
#if defined(POLARSSL_ECP_C)
    if( pk_get_type( key ) == POLARSSL_PK_ECKEY )
    {
        begin = PEM_BEGIN_PRIVATE_KEY_EC;
        end = PEM_END_PRIVATE_KEY_EC;
    }
    else
#endif
#if defined(__TTS__)
    if ( pk_get_type( key ) == OUR_PK_TTS )
    {
        begin = "-----BEGIN TTS PRIVATE KEY-----\n";
        end = "-----END TTS PRIVATE KEY-----\n";
    }
    else
#endif
#if defined(__TTS_2__)
    if ( pk_get_type( key ) == OUR_PK_TTS2 )
    {
        begin = "-----BEGIN TTS2 PRIVATE KEY-----\n";
        end = "-----END TTS2 PRIVATE KEY-----\n";
    }
    else
#endif
#if defined(__RAINBOW__)
    if ( pk_get_type( key ) == OUR_PK_RAINBOW )
    {
        begin = "-----BEGIN RAINBOW PRIVATE KEY-----\n";
        end = "-----END RAINBOW PRIVATE KEY-----\n";
    }
    else
#endif
#if defined(__RAINBOW_2__)
    if ( pk_get_type( key ) == OUR_PK_RAINBOW2 )
    {
        begin = "-----BEGIN RAINBOW2 PRIVATE KEY-----\n";
        end = "-----END RAINBOW2 PRIVATE KEY-----\n";
    }
    else
#endif
        return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE );

    if( ( ret = pem_write_buffer( begin, end,
                                  output_buf + sizeof(output_buf) - ret,
                                  ret, buf, size, &olen ) ) != 0 )
    {
        return( ret );
    }

    return( 0 );
}