int pk_write_pubkey_der( pk_context *key, unsigned char *buf, size_t size ) { int ret; unsigned char *c; size_t len = 0, par_len = 0, oid_len; const char *oid; c = buf + size; ASN1_CHK_ADD( len, pk_write_pubkey( &c, buf, key ) ); if( c - buf < 1 ) { return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL ); } /* * SubjectPublicKeyInfo ::= SEQUENCE { * algorithm AlgorithmIdentifier, * subjectPublicKey BIT STRING } */ *--c = 0; len += 1; ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_BIT_STRING ) ); /* If we return here (do not write OID) * the result will look OK... */ /* return len; */ if( ( ret = oid_get_oid_by_pk_alg( pk_get_type( key ), &oid, &oid_len ) ) != 0 ) { return( ret ); } #if defined(POLARSSL_ECP_C) if( pk_get_type( key ) == POLARSSL_PK_ECKEY ) { ASN1_CHK_ADD( par_len, pk_write_ec_param( &c, buf, pk_ec( *key ) ) ); } #endif ASN1_CHK_ADD( len, asn1_write_algorithm_identifier( &c, buf, oid, oid_len, par_len ) ); ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); return( (int) len ); }
int pk_write_pubkey( unsigned char **p, unsigned char *start, const pk_context *key ) { int ret; size_t len = 0; #if defined(POLARSSL_RSA_C) if( pk_get_type( key ) == POLARSSL_PK_RSA ) ASN1_CHK_ADD( len, pk_write_rsa_pubkey( p, start, pk_rsa( *key ) ) ); else #endif #if defined(POLARSSL_ECP_C) if( pk_get_type( key ) == POLARSSL_PK_ECKEY ) ASN1_CHK_ADD( len, pk_write_ec_pubkey( p, start, pk_ec( *key ) ) ); else #endif return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE ); return( (int) len ); }
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 ); }
result_t PKey::copy(const pk_context &key) { pk_type_t type = pk_get_type(&key); int ret; if (type == POLARSSL_PK_RSA) { rsa_context *rsa = pk_rsa(key); ret = pk_init_ctx(&m_key, pk_info_from_type(POLARSSL_PK_RSA)); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); rsa_context *rsa1 = pk_rsa(m_key); ret = rsa_copy(rsa1, rsa); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); return 0; } if (type == POLARSSL_PK_ECKEY) { ecp_keypair *ecp = pk_ec(key); ret = pk_init_ctx(&m_key, pk_info_from_type(POLARSSL_PK_ECKEY)); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); ecp_keypair *ecp1 = pk_ec(m_key); ret = ecp_group_copy(&ecp1->grp, &ecp->grp); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); ret = mpi_copy(&ecp1->d, &ecp->d); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); ret = ecp_copy(&ecp1->Q, &ecp->Q); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); return 0; } return CHECK_ERROR(CALL_E_INVALID_CALL); }
result_t PKey::isPrivate(bool &retVal) { pk_type_t type = pk_get_type(&m_key); if (type == POLARSSL_PK_RSA) { retVal = rsa_check_privkey(pk_rsa(m_key)) == 0; return 0; } if (type == POLARSSL_PK_ECKEY) { ecp_keypair *ecp = pk_ec(m_key); retVal = ecp_check_privkey(&ecp->grp, &ecp->d) == 0; return 0; } return CHECK_ERROR(CALL_E_INVALID_CALL); }
int pk_write_pubkey( unsigned char **p, unsigned char *start, const pk_context *key ) { int ret; size_t len = 0; #if defined(POLARSSL_RSA_C) if( pk_get_type( key ) == POLARSSL_PK_RSA ) ASN1_CHK_ADD( len, pk_write_rsa_pubkey( p, start, pk_rsa( *key ) ) ); else #endif #if defined(POLARSSL_ECP_C) if( pk_get_type( key ) == POLARSSL_PK_ECKEY ) ASN1_CHK_ADD( len, pk_write_ec_pubkey( p, start, pk_ec( *key ) ) ); else #endif #if defined(__TTS__) if( pk_get_type( key ) == OUR_PK_TTS ) { ASN1_CHK_ADD( len, pk_write_tts_pubkey( p, start, pk_tts( *key ) ) ); } else #endif #if defined(__TTS_2__) if( pk_get_type( key ) == OUR_PK_TTS2 ) { ASN1_CHK_ADD( len, pk_write_tts2_pubkey( p, start, pk_tts2( *key ) ) ); } else #endif #if defined(__RAINBOW__) if( pk_get_type( key ) == OUR_PK_RAINBOW ) { ASN1_CHK_ADD( len, pk_write_rb_pubkey( p, start, pk_rainbow( *key ) ) ); } else #endif #if defined(__RAINBOW_2__) if( pk_get_type( key ) == OUR_PK_RAINBOW2 ) { ASN1_CHK_ADD( len, pk_write_rb2_pubkey( p, start, pk_rainbow2( *key ) ) ); } else #endif return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE ); return( (int) len ); }
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 ); }
int pk_write_key_der( pk_context *key, unsigned char *buf, size_t size ) { int ret; unsigned char *c = buf + size; size_t len = 0; #if defined(POLARSSL_RSA_C) if( pk_get_type( key ) == POLARSSL_PK_RSA ) { rsa_context *rsa = pk_rsa( *key ); ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->QP ) ); ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->DQ ) ); ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->DP ) ); ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->Q ) ); ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->P ) ); ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->D ) ); ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->E ) ); ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &rsa->N ) ); ASN1_CHK_ADD( len, asn1_write_int( &c, buf, 0 ) ); ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); } else #endif /* POLARSSL_RSA_C */ #if defined(POLARSSL_ECP_C) if( pk_get_type( key ) == POLARSSL_PK_ECKEY ) { ecp_keypair *ec = pk_ec( *key ); size_t pub_len = 0, par_len = 0; /* * RFC 5915, or SEC1 Appendix C.4 * * ECPrivateKey ::= SEQUENCE { * version INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1), * privateKey OCTET STRING, * parameters [0] ECParameters {{ NamedCurve }} OPTIONAL, * publicKey [1] BIT STRING OPTIONAL * } */ /* publicKey */ ASN1_CHK_ADD( pub_len, pk_write_ec_pubkey( &c, buf, ec ) ); if( c - buf < 1 ) return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL ); *--c = 0; pub_len += 1; ASN1_CHK_ADD( pub_len, asn1_write_len( &c, buf, pub_len ) ); ASN1_CHK_ADD( pub_len, asn1_write_tag( &c, buf, ASN1_BIT_STRING ) ); ASN1_CHK_ADD( pub_len, asn1_write_len( &c, buf, pub_len ) ); ASN1_CHK_ADD( pub_len, asn1_write_tag( &c, buf, ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 1 ) ); len += pub_len; /* parameters */ ASN1_CHK_ADD( par_len, pk_write_ec_param( &c, buf, ec ) ); ASN1_CHK_ADD( par_len, asn1_write_len( &c, buf, par_len ) ); ASN1_CHK_ADD( par_len, asn1_write_tag( &c, buf, ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 0 ) ); len += par_len; /* privateKey: write as MPI then fix tag */ ASN1_CHK_ADD( len, asn1_write_mpi( &c, buf, &ec->d ) ); *c = ASN1_OCTET_STRING; /* version */ ASN1_CHK_ADD( len, asn1_write_int( &c, buf, 1 ) ); ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); } else #endif /* POLARSSL_ECP_C */ #if defined(__TTS__) if( pk_get_type( key ) == OUR_PK_TTS ) { len += TTS_SECKEY_SIZE_BYTE + TTS_PUBKEY_SIZE_BYTE; if( c - buf < (int) len ) return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL ); c -= len; memcpy( c, &pk_tts( *key )->sk, TTS_SECKEY_SIZE_BYTE ); memcpy( c + TTS_SECKEY_SIZE_BYTE, &pk_tts( *key )->pk, TTS_PUBKEY_SIZE_BYTE ); ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_BIT_STRING ) ); return (int) len; } else #endif /* __TTS__ */ #if defined(__TTS_2__) if( pk_get_type( key ) == OUR_PK_TTS2 ) { len += TTS2_SECKEY_SIZE_BYTE + TTS2_PUBKEY_SIZE_BYTE; if( c - buf < (int) len ) return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL ); c -= len; memcpy( c, &pk_tts2( *key )->sk, TTS2_SECKEY_SIZE_BYTE ); memcpy( c + TTS2_SECKEY_SIZE_BYTE, &pk_tts2( *key )->pk, TTS2_PUBKEY_SIZE_BYTE ); ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_BIT_STRING ) ); return (int) len; } else #endif /* __TTS_2__ */ #if defined(__RAINBOW__) if( pk_get_type( key ) == OUR_PK_RAINBOW ) { len += RB_SECKEY_SIZE_BYTE + RB_PUBKEY_SIZE_BYTE; if( c - buf < (int) len ) return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL ); c -= len; memcpy( c, &pk_rainbow( *key )->sk, RB_SECKEY_SIZE_BYTE ); memcpy( c + RB_SECKEY_SIZE_BYTE, &pk_rainbow( *key )->pk, RB_PUBKEY_SIZE_BYTE ); ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_BIT_STRING ) ); return (int) len; } else #endif /* __RAINBOW__ */ #if defined(__RAINBOW_2__) if( pk_get_type( key ) == OUR_PK_RAINBOW2 ) { len += RB2_SECKEY_SIZE_BYTE + RB2_PUBKEY_SIZE_BYTE; if( c - buf < (int) len ) return( POLARSSL_ERR_ASN1_BUF_TOO_SMALL ); c -= len; memcpy( c, &pk_rainbow2( *key )->sk, RB2_SECKEY_SIZE_BYTE ); memcpy( c + RB2_SECKEY_SIZE_BYTE, &pk_rainbow2( *key )->pk, RB2_PUBKEY_SIZE_BYTE ); ASN1_CHK_ADD( len, asn1_write_len( &c, buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, buf, ASN1_BIT_STRING ) ); return (int) len; } else #endif /* __RAINBOW_2__ */ return( POLARSSL_ERR_PK_FEATURE_UNAVAILABLE ); return( (int) len ); }
int main( int argc, char *argv[] ) { int ret = 0; pk_context pk; char buf[1024]; int i; char *p, *q; /* * Set to sane values */ pk_init( &pk ); memset( buf, 0, sizeof(buf) ); if( argc == 0 ) { usage: printf( USAGE ); goto exit; } opt.mode = DFL_MODE; opt.filename = DFL_FILENAME; opt.password = DFL_PASSWORD; opt.password_file = DFL_PASSWORD_FILE; for( i = 1; i < argc; i++ ) { p = argv[i]; if( ( q = strchr( p, '=' ) ) == NULL ) goto usage; *q++ = '\0'; if( strcmp( p, "mode" ) == 0 ) { if( strcmp( q, "private" ) == 0 ) opt.mode = MODE_PRIVATE; else if( strcmp( q, "public" ) == 0 ) opt.mode = MODE_PUBLIC; else goto usage; } else if( strcmp( p, "filename" ) == 0 ) opt.filename = q; else if( strcmp( p, "password" ) == 0 ) opt.password = q; else if( strcmp( p, "password_file" ) == 0 ) opt.password_file = q; else goto usage; } if( opt.mode == MODE_PRIVATE ) { if( strlen( opt.password ) && strlen( opt.password_file ) ) { printf( "Error: cannot have both password and password_file\n" ); goto usage; } if( strlen( opt.password_file ) ) { FILE *f; printf( "\n . Loading the password file ..." ); if( ( f = fopen( opt.password_file, "rb" ) ) == NULL ) { printf( " failed\n ! fopen returned NULL\n" ); goto exit; } fgets( buf, sizeof(buf), f ); fclose( f ); i = (int) strlen( buf ); if( buf[i - 1] == '\n' ) buf[i - 1] = '\0'; if( buf[i - 2] == '\r' ) buf[i - 2] = '\0'; opt.password = buf; } /* * 1.1. Load the key */ printf( "\n . Loading the private key ..." ); fflush( stdout ); ret = pk_parse_keyfile( &pk, opt.filename, opt.password ); if( ret != 0 ) { printf( " failed\n ! pk_parse_keyfile returned -0x%04x\n", -ret ); goto exit; } printf( " ok\n" ); /* * 1.2 Print the key */ printf( " . Key information ...\n" ); #if defined(POLARSSL_RSA_C) if( pk_get_type( &pk ) == POLARSSL_PK_RSA ) { rsa_context *rsa = pk_rsa( pk ); mpi_write_file( "N: ", &rsa->N, 16, NULL ); mpi_write_file( "E: ", &rsa->E, 16, NULL ); mpi_write_file( "D: ", &rsa->D, 16, NULL ); mpi_write_file( "P: ", &rsa->P, 16, NULL ); mpi_write_file( "Q: ", &rsa->Q, 16, NULL ); mpi_write_file( "DP: ", &rsa->DP, 16, NULL ); mpi_write_file( "DQ: ", &rsa->DQ, 16, NULL ); mpi_write_file( "QP: ", &rsa->QP, 16, NULL ); } else #endif #if defined(POLARSSL_ECP_C) if( pk_get_type( &pk ) == POLARSSL_PK_ECKEY ) { ecp_keypair *ecp = pk_ec( pk ); mpi_write_file( "Q(X): ", &ecp->Q.X, 16, NULL ); mpi_write_file( "Q(Y): ", &ecp->Q.Y, 16, NULL ); mpi_write_file( "Q(Z): ", &ecp->Q.Z, 16, NULL ); mpi_write_file( "D : ", &ecp->d , 16, NULL ); } else #endif { printf("Do not know how to print key information for this type\n" ); goto exit; } } else if( opt.mode == MODE_PUBLIC ) { /* * 1.1. Load the key */ printf( "\n . Loading the public key ..." ); fflush( stdout ); ret = pk_parse_public_keyfile( &pk, opt.filename ); if( ret != 0 ) { printf( " failed\n ! pk_parse_public_keyfile returned -0x%04x\n", -ret ); goto exit; } printf( " ok\n" ); printf( " . Key information ...\n" ); #if defined(POLARSSL_RSA_C) if( pk_get_type( &pk ) == POLARSSL_PK_RSA ) { rsa_context *rsa = pk_rsa( pk ); mpi_write_file( "N: ", &rsa->N, 16, NULL ); mpi_write_file( "E: ", &rsa->E, 16, NULL ); } else #endif #if defined(POLARSSL_ECP_C) if( pk_get_type( &pk ) == POLARSSL_PK_ECKEY ) { ecp_keypair *ecp = pk_ec( pk ); mpi_write_file( "Q(X): ", &ecp->Q.X, 16, NULL ); mpi_write_file( "Q(Y): ", &ecp->Q.Y, 16, NULL ); mpi_write_file( "Q(Z): ", &ecp->Q.Z, 16, NULL ); } else #endif { printf("Do not know how to print key information for this type\n" ); goto exit; } } else goto usage; exit: #if defined(POLARSSL_ERROR_C) polarssl_strerror( ret, buf, sizeof(buf) ); printf( " ! Last error was: %s\n", buf ); #endif pk_free( &pk ); #if defined(_WIN32) printf( " + Press Enter to exit this program.\n" ); fflush( stdout ); getchar(); #endif return( ret ); }
void PKey::clear() { if (pk_get_type(&m_key)) pk_free(&m_key); }
result_t PKey::get_publicKey(obj_ptr<PKey_base> &retVal) { result_t hr; bool priv; hr = isPrivate(priv); if (hr < 0) return hr; if (!priv) return CALL_RETURN_NULL; pk_type_t type = pk_get_type(&m_key); int ret; if (type == POLARSSL_PK_RSA) { rsa_context *rsa = pk_rsa(m_key); obj_ptr<PKey> pk1 = new PKey(); ret = pk_init_ctx(&pk1->m_key, pk_info_from_type(POLARSSL_PK_RSA)); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); rsa_context *rsa1 = pk_rsa(pk1->m_key); rsa1->len = rsa->len; rsa1->padding = rsa->padding; rsa1->hash_id = rsa->hash_id; ret = mpi_copy(&rsa1->N, &rsa->N); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); ret = mpi_copy(&rsa1->E, &rsa->E); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); retVal = pk1; return 0; } if (type == POLARSSL_PK_ECKEY) { ecp_keypair *ecp = pk_ec(m_key); obj_ptr<PKey> pk1 = new PKey(); ret = pk_init_ctx(&pk1->m_key, pk_info_from_type(POLARSSL_PK_ECKEY)); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); ecp_keypair *ecp1 = pk_ec(pk1->m_key); ret = ecp_group_copy(&ecp1->grp, &ecp->grp); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); ret = ecp_copy(&ecp1->Q, &ecp->Q); if (ret != 0) return CHECK_ERROR(_ssl::setError(ret)); retVal = pk1; return 0; } return CHECK_ERROR(CALL_E_INVALID_CALL); }
int x509write_csr_der( x509write_csr *ctx, unsigned char *buf, size_t size, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { int ret; const char *sig_oid; size_t sig_oid_len = 0; unsigned char *c, *c2; unsigned char hash[64]; unsigned char sig[POLARSSL_MPI_MAX_SIZE]; unsigned char tmp_buf[2048]; size_t pub_len = 0, sig_and_oid_len = 0, sig_len; size_t len = 0; pk_type_t pk_alg; /* * Prepare data to be signed in tmp_buf */ c = tmp_buf + sizeof( tmp_buf ); ASN1_CHK_ADD( len, x509_write_extensions( &c, tmp_buf, ctx->extensions ) ); if( len ) { ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED | ASN1_SET ) ); ASN1_CHK_ADD( len, asn1_write_oid( &c, tmp_buf, OID_PKCS9_CSR_EXT_REQ, OID_SIZE( OID_PKCS9_CSR_EXT_REQ ) ) ); ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); } ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED | ASN1_CONTEXT_SPECIFIC ) ); ASN1_CHK_ADD( pub_len, pk_write_pubkey_der( ctx->key, tmp_buf, c - tmp_buf ) ); c -= pub_len; len += pub_len; /* * Subject ::= Name */ ASN1_CHK_ADD( len, x509_write_names( &c, tmp_buf, ctx->subject ) ); /* * Version ::= INTEGER { v1(0), v2(1), v3(2) } */ ASN1_CHK_ADD( len, asn1_write_int( &c, tmp_buf, 0 ) ); ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); /* * Prepare signature */ md( md_info_from_type( ctx->md_alg ), c, len, hash ); pk_alg = pk_get_type( ctx->key ); if( pk_alg == POLARSSL_PK_ECKEY ) pk_alg = POLARSSL_PK_ECDSA; if( ( ret = pk_sign( ctx->key, ctx->md_alg, hash, 0, sig, &sig_len, f_rng, p_rng ) ) != 0 || ( ret = oid_get_oid_by_sig_alg( pk_alg, ctx->md_alg, &sig_oid, &sig_oid_len ) ) != 0 ) { return( ret ); } /* * Write data to output buffer */ c2 = buf + size; ASN1_CHK_ADD( sig_and_oid_len, x509_write_sig( &c2, buf, sig_oid, sig_oid_len, sig, sig_len ) ); c2 -= len; memcpy( c2, c, len ); len += sig_and_oid_len; ASN1_CHK_ADD( len, asn1_write_len( &c2, buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c2, buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); return( (int) len ); }
int main( int argc, char *argv[] ) { int ret = 0; pk_context key; char buf[1024]; int i; char *p, *q; /* * Set to sane values */ pk_init( &key ); memset( buf, 0, sizeof( buf ) ); if( argc == 0 ) { usage: ret = 1; polarssl_printf( USAGE ); goto exit; } opt.mode = DFL_MODE; opt.filename = DFL_FILENAME; opt.output_mode = DFL_OUTPUT_MODE; opt.output_file = DFL_OUTPUT_FILENAME; opt.output_format = DFL_OUTPUT_FORMAT; for( i = 1; i < argc; i++ ) { p = argv[i]; if( ( q = strchr( p, '=' ) ) == NULL ) goto usage; *q++ = '\0'; if( strcmp( p, "mode" ) == 0 ) { if( strcmp( q, "private" ) == 0 ) opt.mode = MODE_PRIVATE; else if( strcmp( q, "public" ) == 0 ) opt.mode = MODE_PUBLIC; else goto usage; } else if( strcmp( p, "output_mode" ) == 0 ) { if( strcmp( q, "private" ) == 0 ) opt.output_mode = OUTPUT_MODE_PRIVATE; else if( strcmp( q, "public" ) == 0 ) opt.output_mode = OUTPUT_MODE_PUBLIC; else goto usage; } else if( strcmp( p, "output_format" ) == 0 ) { #if defined(POLARSSL_PEM_WRITE_C) if( strcmp( q, "pem" ) == 0 ) opt.output_format = OUTPUT_FORMAT_PEM; else #endif if( strcmp( q, "der" ) == 0 ) opt.output_format = OUTPUT_FORMAT_DER; else goto usage; } else if( strcmp( p, "filename" ) == 0 ) opt.filename = q; else if( strcmp( p, "output_file" ) == 0 ) opt.output_file = q; else goto usage; } if( opt.mode == MODE_NONE && opt.output_mode != OUTPUT_MODE_NONE ) { polarssl_printf( "\nCannot output a key without reading one.\n"); goto exit; } if( opt.mode == MODE_PUBLIC && opt.output_mode == OUTPUT_MODE_PRIVATE ) { polarssl_printf( "\nCannot output a private key from a public key.\n"); goto exit; } if( opt.mode == MODE_PRIVATE ) { /* * 1.1. Load the key */ polarssl_printf( "\n . Loading the private key ..." ); fflush( stdout ); ret = pk_parse_keyfile( &key, opt.filename, NULL ); if( ret != 0 ) { polarssl_strerror( ret, (char *) buf, sizeof(buf) ); polarssl_printf( " failed\n ! pk_parse_keyfile returned -0x%04x - %s\n\n", -ret, buf ); goto exit; } polarssl_printf( " ok\n" ); /* * 1.2 Print the key */ polarssl_printf( " . Key information ...\n" ); #if defined(POLARSSL_RSA_C) if( pk_get_type( &key ) == POLARSSL_PK_RSA ) { rsa_context *rsa = pk_rsa( key ); mpi_write_file( "N: ", &rsa->N, 16, NULL ); mpi_write_file( "E: ", &rsa->E, 16, NULL ); mpi_write_file( "D: ", &rsa->D, 16, NULL ); mpi_write_file( "P: ", &rsa->P, 16, NULL ); mpi_write_file( "Q: ", &rsa->Q, 16, NULL ); mpi_write_file( "DP: ", &rsa->DP, 16, NULL ); mpi_write_file( "DQ: ", &rsa->DQ, 16, NULL ); mpi_write_file( "QP: ", &rsa->QP, 16, NULL ); } else #endif #if defined(POLARSSL_ECP_C) if( pk_get_type( &key ) == POLARSSL_PK_ECKEY ) { ecp_keypair *ecp = pk_ec( key ); mpi_write_file( "Q(X): ", &ecp->Q.X, 16, NULL ); mpi_write_file( "Q(Y): ", &ecp->Q.Y, 16, NULL ); mpi_write_file( "Q(Z): ", &ecp->Q.Z, 16, NULL ); mpi_write_file( "D : ", &ecp->d , 16, NULL ); } else #endif polarssl_printf("key type not supported yet\n"); } else if( opt.mode == MODE_PUBLIC ) { /* * 1.1. Load the key */ polarssl_printf( "\n . Loading the public key ..." ); fflush( stdout ); ret = pk_parse_public_keyfile( &key, opt.filename ); if( ret != 0 ) { polarssl_strerror( ret, (char *) buf, sizeof(buf) ); polarssl_printf( " failed\n ! pk_parse_public_key returned -0x%04x - %s\n\n", -ret, buf ); goto exit; } polarssl_printf( " ok\n" ); /* * 1.2 Print the key */ polarssl_printf( " . Key information ...\n" ); #if defined(POLARSSL_RSA_C) if( pk_get_type( &key ) == POLARSSL_PK_RSA ) { rsa_context *rsa = pk_rsa( key ); mpi_write_file( "N: ", &rsa->N, 16, NULL ); mpi_write_file( "E: ", &rsa->E, 16, NULL ); } else #endif #if defined(POLARSSL_ECP_C) if( pk_get_type( &key ) == POLARSSL_PK_ECKEY ) { ecp_keypair *ecp = pk_ec( key ); mpi_write_file( "Q(X): ", &ecp->Q.X, 16, NULL ); mpi_write_file( "Q(Y): ", &ecp->Q.Y, 16, NULL ); mpi_write_file( "Q(Z): ", &ecp->Q.Z, 16, NULL ); } else #endif polarssl_printf("key type not supported yet\n"); } else goto usage; if( opt.output_mode == OUTPUT_MODE_PUBLIC ) { write_public_key( &key, opt.output_file ); } if( opt.output_mode == OUTPUT_MODE_PRIVATE ) { write_private_key( &key, opt.output_file ); } exit: if( ret != 0 && ret != 1) { #ifdef POLARSSL_ERROR_C polarssl_strerror( ret, buf, sizeof( buf ) ); polarssl_printf( " - %s\n", buf ); #else polarssl_printf("\n"); #endif } pk_free( &key ); #if defined(_WIN32) polarssl_printf( " + Press Enter to exit this program.\n" ); fflush( stdout ); getchar(); #endif return( ret ); }
int main( int argc, char *argv[] ) { int ret = 0; pk_context key; char buf[1024]; int i; char *p, *q; entropy_context entropy; ctr_drbg_context ctr_drbg; const char *pers = "gen_key"; #if defined(POLARSSL_ECP_C) const ecp_curve_info *curve_info; #endif /* * Set to sane values */ pk_init( &key ); memset( buf, 0, sizeof( buf ) ); if( argc == 0 ) { usage: ret = 1; printf( USAGE ); #if defined(POLARSSL_ECP_C) printf( " availabled ec_curve values:\n" ); curve_info = ecp_curve_list(); printf( " %s (default)\n", curve_info->name ); while( ( ++curve_info )->name != NULL ) printf( " %s\n", curve_info->name ); #endif goto exit; } opt.type = DFL_TYPE; opt.rsa_keysize = DFL_RSA_KEYSIZE; opt.ec_curve = DFL_EC_CURVE; opt.filename = DFL_FILENAME; opt.format = DFL_FORMAT; opt.use_dev_random = DFL_USE_DEV_RANDOM; for( i = 1; i < argc; i++ ) { p = argv[i]; if( ( q = strchr( p, '=' ) ) == NULL ) goto usage; *q++ = '\0'; if( strcmp( p, "type" ) == 0 ) { if( strcmp( q, "rsa" ) == 0 ) opt.type = POLARSSL_PK_RSA; else if( strcmp( q, "ec" ) == 0 ) opt.type = POLARSSL_PK_ECKEY; else goto usage; } else if( strcmp( p, "format" ) == 0 ) { if( strcmp( q, "pem" ) == 0 ) opt.format = FORMAT_PEM; else if( strcmp( q, "der" ) == 0 ) opt.format = FORMAT_DER; else goto usage; } else if( strcmp( p, "rsa_keysize" ) == 0 ) { opt.rsa_keysize = atoi( q ); if( opt.rsa_keysize < 1024 || opt.rsa_keysize > 8192 ) goto usage; } else if( strcmp( p, "ec_curve" ) == 0 ) { if( ( curve_info = ecp_curve_info_from_name( q ) ) == NULL ) goto usage; opt.ec_curve = curve_info->grp_id; } else if( strcmp( p, "filename" ) == 0 ) opt.filename = q; else if( strcmp( p, "use_dev_random" ) == 0 ) { opt.use_dev_random = atoi( q ); if( opt.use_dev_random < 0 || opt.use_dev_random > 1 ) goto usage; } else goto usage; } printf( "\n . Seeding the random number generator..." ); fflush( stdout ); entropy_init( &entropy ); #if !defined(_WIN32) && defined(POLARSSL_FS_IO) if( opt.use_dev_random ) { if( ( ret = entropy_add_source( &entropy, dev_random_entropy_poll, NULL, DEV_RANDOM_THRESHOLD ) ) != 0 ) { printf( " failed\n ! entropy_add_source returned -0x%04x\n", -ret ); goto exit; } printf("\n Using /dev/random, so can take a long time! " ); fflush( stdout ); } #endif /* !_WIN32 && POLARSSL_FS_IO */ if( ( ret = ctr_drbg_init( &ctr_drbg, entropy_func, &entropy, (const unsigned char *) pers, strlen( pers ) ) ) != 0 ) { printf( " failed\n ! ctr_drbg_init returned -0x%04x\n", -ret ); goto exit; } /* * 1.1. Generate the key */ printf( "\n . Generating the private key ..." ); fflush( stdout ); if( ( ret = pk_init_ctx( &key, pk_info_from_type( opt.type ) ) ) != 0 ) { printf( " failed\n ! pk_init_ctx returned -0x%04x", -ret ); goto exit; } #if defined(POLARSSL_RSA_C) && defined(POLARSSL_GENPRIME) if( opt.type == POLARSSL_PK_RSA ) { ret = rsa_gen_key( pk_rsa( key ), ctr_drbg_random, &ctr_drbg, opt.rsa_keysize, 65537 ); if( ret != 0 ) { printf( " failed\n ! rsa_gen_key returned -0x%04x", -ret ); goto exit; } } else #endif /* POLARSSL_RSA_C */ #if defined(POLARSSL_ECP_C) if( opt.type == POLARSSL_PK_ECKEY ) { ret = ecp_gen_key( opt.ec_curve, pk_ec( key ), ctr_drbg_random, &ctr_drbg ); if( ret != 0 ) { printf( " failed\n ! rsa_gen_key returned -0x%04x", -ret ); goto exit; } } else #endif /* POLARSSL_ECP_C */ { printf( " failed\n ! key type not supported\n" ); goto exit; } /* * 1.2 Print the key */ printf( " ok\n . Key information:\n" ); #if defined(POLARSSL_RSA_C) if( pk_get_type( &key ) == POLARSSL_PK_RSA ) { rsa_context *rsa = pk_rsa( key ); mpi_write_file( "N: ", &rsa->N, 16, NULL ); mpi_write_file( "E: ", &rsa->E, 16, NULL ); mpi_write_file( "D: ", &rsa->D, 16, NULL ); mpi_write_file( "P: ", &rsa->P, 16, NULL ); mpi_write_file( "Q: ", &rsa->Q, 16, NULL ); mpi_write_file( "DP: ", &rsa->DP, 16, NULL ); mpi_write_file( "DQ: ", &rsa->DQ, 16, NULL ); mpi_write_file( "QP: ", &rsa->QP, 16, NULL ); } else #endif #if defined(POLARSSL_ECP_C) if( pk_get_type( &key ) == POLARSSL_PK_ECKEY ) { ecp_keypair *ecp = pk_ec( key ); printf( "curve: %s\n", ecp_curve_info_from_grp_id( ecp->grp.id )->name ); mpi_write_file( "X_Q: ", &ecp->Q.X, 16, NULL ); mpi_write_file( "Y_Q: ", &ecp->Q.Y, 16, NULL ); mpi_write_file( "D: ", &ecp->d , 16, NULL ); } else #endif printf(" ! key type not supported\n"); write_private_key( &key, opt.filename ); exit: if( ret != 0 && ret != 1) { #ifdef POLARSSL_ERROR_C polarssl_strerror( ret, buf, sizeof( buf ) ); printf( " - %s\n", buf ); #else printf("\n"); #endif } pk_free( &key ); ctr_drbg_free( &ctr_drbg ); entropy_free( &entropy ); #if defined(_WIN32) printf( " + Press Enter to exit this program.\n" ); fflush( stdout ); getchar(); #endif return( ret ); }
int x509write_crt_der( x509write_cert *ctx, unsigned char *buf, size_t size, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng ) { int ret; const char *sig_oid; size_t sig_oid_len = 0; unsigned char *c, *c2; unsigned char hash[64]; unsigned char sig[POLARSSL_MPI_MAX_SIZE]; unsigned char tmp_buf[2048]; size_t sub_len = 0, pub_len = 0, sig_and_oid_len = 0, sig_len; size_t len = 0; pk_type_t pk_alg; /* * Prepare data to be signed in tmp_buf */ c = tmp_buf + sizeof( tmp_buf ); /* Signature algorithm needed in TBS, and later for actual signature */ pk_alg = pk_get_type( ctx->issuer_key ); if( pk_alg == POLARSSL_PK_ECKEY ) pk_alg = POLARSSL_PK_ECDSA; if( ( ret = oid_get_oid_by_sig_alg( pk_alg, ctx->md_alg, &sig_oid, &sig_oid_len ) ) != 0 ) { return( ret ); } /* * Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension */ ASN1_CHK_ADD( len, x509_write_extensions( &c, tmp_buf, ctx->extensions ) ); ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 3 ) ); /* * SubjectPublicKeyInfo */ ASN1_CHK_ADD( pub_len, pk_write_pubkey_der( ctx->subject_key, tmp_buf, c - tmp_buf ) ); c -= pub_len; len += pub_len; /* * Subject ::= Name */ ASN1_CHK_ADD( len, x509_write_names( &c, tmp_buf, ctx->subject ) ); /* * Validity ::= SEQUENCE { * notBefore Time, * notAfter Time } */ sub_len = 0; ASN1_CHK_ADD( sub_len, x509_write_time( &c, tmp_buf, ctx->not_after, X509_RFC5280_UTC_TIME_LEN ) ); ASN1_CHK_ADD( sub_len, x509_write_time( &c, tmp_buf, ctx->not_before, X509_RFC5280_UTC_TIME_LEN ) ); len += sub_len; ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, sub_len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); /* * Issuer ::= Name */ ASN1_CHK_ADD( len, x509_write_names( &c, tmp_buf, ctx->issuer ) ); /* * Signature ::= AlgorithmIdentifier */ ASN1_CHK_ADD( len, asn1_write_algorithm_identifier( &c, tmp_buf, sig_oid, strlen( sig_oid ), 0 ) ); /* * Serial ::= INTEGER */ ASN1_CHK_ADD( len, asn1_write_mpi( &c, tmp_buf, &ctx->serial ) ); /* * Version ::= INTEGER { v1(0), v2(1), v3(2) } */ sub_len = 0; ASN1_CHK_ADD( sub_len, asn1_write_int( &c, tmp_buf, ctx->version ) ); len += sub_len; ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, sub_len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 0 ) ); ASN1_CHK_ADD( len, asn1_write_len( &c, tmp_buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c, tmp_buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); /* * Make signature */ md( md_info_from_type( ctx->md_alg ), c, len, hash ); if( ( ret = pk_sign( ctx->issuer_key, ctx->md_alg, hash, 0, sig, &sig_len, f_rng, p_rng ) ) != 0 ) { return( ret ); } /* * Write data to output buffer */ c2 = buf + size; ASN1_CHK_ADD( sig_and_oid_len, x509_write_sig( &c2, buf, sig_oid, sig_oid_len, sig, sig_len ) ); c2 -= len; memcpy( c2, c, len ); len += sig_and_oid_len; ASN1_CHK_ADD( len, asn1_write_len( &c2, buf, len ) ); ASN1_CHK_ADD( len, asn1_write_tag( &c2, buf, ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ); return( (int) len ); }
bool cCryptoKey::IsValid(void) const { return (pk_get_type(&m_Pk) != POLARSSL_PK_NONE); }