/*
* Read a counterparty client hello
*/
Client_Hello::Client_Hello(const std::vector<uint8_t>& buf)
{
if(buf.size() < 41)
throw Decoding_Error("Client_Hello: Packet corrupted");
TLS_Data_Reader reader("ClientHello", buf);
const uint8_t major_version = reader.get_byte();
const uint8_t minor_version = reader.get_byte();
m_version = Protocol_Version(major_version, minor_version);
m_random = reader.get_fixed<uint8_t>(32);
m_session_id = reader.get_range<uint8_t>(1, 0, 32);
if(m_version.is_datagram_protocol())
m_hello_cookie = reader.get_range<uint8_t>(1, 0, 255);
m_suites = reader.get_range_vector<uint16_t>(2, 1, 32767);
m_comp_methods = reader.get_range_vector<uint8_t>(1, 1, 255);
m_extensions.deserialize(reader);
if(offered_suite(static_cast<uint16_t>(TLS_EMPTY_RENEGOTIATION_INFO_SCSV)))
{
if(Renegotiation_Extension* reneg = m_extensions.get<Renegotiation_Extension>())
{
if(!reneg->renegotiation_info().empty())
throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
"Client sent renegotiation SCSV and non-empty extension");
}
else
{
// add fake extension
m_extensions.add(new Renegotiation_Extension());
}
}
// Parsing complete, now any additional decoding checks
if(m_version.supports_negotiable_signature_algorithms() == false)
{
if(m_extensions.has<Signature_Algorithms>())
throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
"Client sent signature_algorithms extension in version that doesn't support it");
}
}
void TLS::Callbacks::tls_verify_cert_chain(
const std::vector<X509_Certificate>& cert_chain,
const std::vector<std::shared_ptr<const OCSP::Response>>& ocsp_responses,
const std::vector<Certificate_Store*>& trusted_roots,
Usage_Type usage,
const std::string& hostname,
const TLS::Policy& policy)
{
if(cert_chain.empty())
throw Invalid_Argument("Certificate chain was empty");
Path_Validation_Restrictions restrictions(policy.require_cert_revocation_info(),
policy.minimum_signature_strength());
Path_Validation_Result result =
x509_path_validate(cert_chain,
restrictions,
trusted_roots,
(usage == Usage_Type::TLS_SERVER_AUTH ? hostname : ""),
usage,
std::chrono::system_clock::now(),
tls_verify_cert_chain_ocsp_timeout(),
ocsp_responses);
if(!result.successful_validation())
{
throw TLS_Exception(Alert::BAD_CERTIFICATE,
"Certificate validation failure: " + result.result_string());
}
}
Maximum_Fragment_Length::Maximum_Fragment_Length(TLS_Data_Reader& reader,
u16bit extension_size)
{
if(extension_size != 1)
throw Decoding_Error("Bad size for maximum fragment extension");
const byte val = reader.get_byte();
switch(val)
{
case 1:
m_max_fragment = 512;
break;
case 2:
m_max_fragment = 1024;
break;
case 3:
m_max_fragment = 2048;
break;
case 4:
m_max_fragment = 4096;
break;
default:
throw TLS_Exception(Alert::ILLEGAL_PARAMETER,
"Bad value " + std::to_string(val) + " for max fragment len");
}
}
const std::string& Application_Layer_Protocol_Notification::single_protocol() const
{
if(m_protocols.size() != 1)
throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
"Server sent " + std::to_string(m_protocols.size()) +
" protocols in ALPN extension response");
return m_protocols[0];
}
bool Protocol_Version::operator>(const Protocol_Version& other) const
{
if(this->is_datagram_protocol() != other.is_datagram_protocol())
throw TLS_Exception(Alert::PROTOCOL_VERSION,
"Version comparing " + to_string() +
" with " + other.to_string());
if(this->is_datagram_protocol())
return m_version < other.m_version; // goes backwards
return m_version > other.m_version;
}
/*
* Perform a server-side TLS handshake
*/
void TLS_Server::do_handshake()
{
while(true)
{
if(active && !state)
break;
state_machine();
if(!active && !state)
throw TLS_Exception(HANDSHAKE_FAILURE, "TLS_Server: Handshake failed");
}
}
std::pair<secure_vector<uint8_t>, std::vector<uint8_t>> TLS::Callbacks::tls_dh_agree(
const std::vector<uint8_t>& modulus,
const std::vector<uint8_t>& generator,
const std::vector<uint8_t>& peer_public_value,
const Policy& policy,
RandomNumberGenerator& rng)
{
BigInt p = BigInt::decode(modulus);
BigInt g = BigInt::decode(generator);
BigInt Y = BigInt::decode(peer_public_value);
/*
* A basic check for key validity. As we do not know q here we
* cannot check that Y is in the right subgroup. However since
* our key is ephemeral there does not seem to be any
* advantage to bogus keys anyway.
*/
if(Y <= 1 || Y >= p - 1)
throw TLS_Exception(Alert::ILLEGAL_PARAMETER,
"Server sent bad DH key for DHE exchange");
DL_Group group(p, g);
if(!group.verify_group(rng, false))
throw TLS_Exception(Alert::INSUFFICIENT_SECURITY,
"DH group validation failed");
DH_PublicKey peer_key(group, Y);
policy.check_peer_key_acceptable(peer_key);
DH_PrivateKey priv_key(rng, group);
PK_Key_Agreement ka(priv_key, rng, "Raw");
secure_vector<uint8_t> dh_secret = CT::strip_leading_zeros(
ka.derive_key(0, peer_key.public_value()).bits_of());
return std::make_pair(dh_secret, priv_key.public_value());
}
Heartbeat_Support_Indicator::Heartbeat_Support_Indicator(TLS_Data_Reader& reader,
u16bit extension_size)
{
if(extension_size != 1)
throw Decoding_Error("Strange size for heartbeat extension");
const byte code = reader.get_byte();
if(code != 1 && code != 2)
throw TLS_Exception(Alert::ILLEGAL_PARAMETER,
"Unknown heartbeat code " + std::to_string(code));
m_peer_allowed_to_send = (code == 1);
}
std::pair<secure_vector<uint8_t>, std::vector<uint8_t>> TLS::Callbacks::tls_ecdh_agree(
const std::string& curve_name,
const std::vector<uint8_t>& peer_public_value,
const Policy& policy,
RandomNumberGenerator& rng,
bool compressed)
{
secure_vector<uint8_t> ecdh_secret;
std::vector<uint8_t> our_public_value;
if(curve_name == "x25519")
{
#if defined(BOTAN_HAS_CURVE_25519)
if(peer_public_value.size() != 32)
{
throw TLS_Exception(Alert::HANDSHAKE_FAILURE, "Invalid X25519 key size");
}
Curve25519_PublicKey peer_key(peer_public_value);
policy.check_peer_key_acceptable(peer_key);
Curve25519_PrivateKey priv_key(rng);
PK_Key_Agreement ka(priv_key, rng, "Raw");
ecdh_secret = ka.derive_key(0, peer_key.public_value()).bits_of();
// X25519 is always compressed but sent as "uncompressed" in TLS
our_public_value = priv_key.public_value();
#else
throw Internal_Error("Negotiated X25519 somehow, but it is disabled");
#endif
}
else
{
EC_Group group(OIDS::lookup(curve_name));
ECDH_PublicKey peer_key(group, group.OS2ECP(peer_public_value));
policy.check_peer_key_acceptable(peer_key);
ECDH_PrivateKey priv_key(rng, group);
PK_Key_Agreement ka(priv_key, rng, "Raw");
ecdh_secret = ka.derive_key(0, peer_key.public_value()).bits_of();
our_public_value = priv_key.public_value(compressed ? PointGFp::COMPRESSED : PointGFp::UNCOMPRESSED);
}
return std::make_pair(ecdh_secret, our_public_value);
}
Heartbeat_Message::Heartbeat_Message(const std::vector<byte>& buf)
{
TLS_Data_Reader reader("Heartbeat", buf);
const byte type = reader.get_byte();
if(type != 1 && type != 2)
throw TLS_Exception(Alert::ILLEGAL_PARAMETER,
"Unknown heartbeat message type");
m_type = static_cast<Type>(type);
m_payload = reader.get_range<byte>(2, 0, 16*1024);
m_padding = reader.get_remaining();
if(m_padding.size() < 16)
throw Decoding_Error("Invalid heartbeat padding");
}
std::vector<byte> Application_Layer_Protocol_Notification::serialize() const
{
std::vector<byte> buf(2);
for(auto&& p: m_protocols)
{
if(p.length() >= 256)
throw TLS_Exception(Alert::INTERNAL_ERROR, "ALPN name too long");
if(p != "")
append_tls_length_value(buf,
reinterpret_cast<const byte*>(p.data()),
p.size(),
1);
}
buf[0] = get_byte<u16bit>(0, buf.size()-2);
buf[1] = get_byte<u16bit>(1, buf.size()-2);
return buf;
}
/*
* Return allowed ciphersuites
*/
std::vector<u16bit> TLS_Policy::suite_list(bool use_rsa,
bool use_edh_rsa,
bool use_edh_dsa) const
{
std::vector<u16bit> suites;
if(use_edh_dsa)
{
suites.push_back(TLS_DHE_DSS_WITH_AES_256_CBC_SHA);
suites.push_back(TLS_DHE_DSS_WITH_AES_128_CBC_SHA);
suites.push_back(TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA);
suites.push_back(TLS_DHE_DSS_WITH_SEED_CBC_SHA);
}
if(use_edh_rsa)
{
suites.push_back(TLS_DHE_RSA_WITH_AES_256_CBC_SHA);
suites.push_back(TLS_DHE_RSA_WITH_AES_128_CBC_SHA);
suites.push_back(TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA);
suites.push_back(TLS_DHE_RSA_WITH_SEED_CBC_SHA);
}
if(use_rsa)
{
suites.push_back(TLS_RSA_WITH_AES_256_CBC_SHA);
suites.push_back(TLS_RSA_WITH_AES_128_CBC_SHA);
suites.push_back(TLS_RSA_WITH_3DES_EDE_CBC_SHA);
suites.push_back(TLS_RSA_WITH_SEED_CBC_SHA);
//suites.push_back(TLS_RSA_WITH_RC4_128_SHA);
//suites.push_back(TLS_RSA_WITH_RC4_128_MD5);
}
if(suites.size() == 0)
throw TLS_Exception(INTERNAL_ERROR,
"TLS_Policy error: All ciphersuites disabled");
suites.push_back(TLS_NO_RENEGOTIATION_SCSV);
return suites;
}
void Policy::check_peer_key_acceptable(const Public_Key& public_key) const
{
const std::string algo_name = public_key.algo_name();
const size_t keylength = public_key.key_length();
size_t expected_keylength = 0;
if(algo_name == "RSA")
{
expected_keylength = minimum_rsa_bits();
}
else if(algo_name == "DH")
{
expected_keylength = minimum_dh_group_size();
}
else if(algo_name == "DSA")
{
expected_keylength = minimum_dsa_group_size();
}
else if(algo_name == "ECDH" || algo_name == "Curve25519")
{
expected_keylength = minimum_ecdh_group_size();
}
else if(algo_name == "ECDSA")
{
expected_keylength = minimum_ecdsa_group_size();
}
// else some other algo, so leave expected_keylength as zero and the check is a no-op
if(keylength < expected_keylength)
throw TLS_Exception(Alert::INSUFFICIENT_SECURITY,
"Peer sent " +
std::to_string(keylength) + " bit " + algo_name + " key"
", policy requires at least " +
std::to_string(expected_keylength));
}
/*
* Process a handshake message
*/
void TLS_Server::process_handshake_msg(Handshake_Type type,
const MemoryRegion<byte>& contents)
{
rng.add_entropy(&contents[0], contents.size());
if(state == 0)
throw Unexpected_Message("Unexpected handshake message");
if(active && (type == CLIENT_HELLO || type == CLIENT_HELLO_SSLV2))
{
delete state;
state = 0;
writer.alert(WARNING, NO_RENEGOTIATION);
return;
}
if(type != HANDSHAKE_CCS && type != FINISHED)
{
if(type != CLIENT_HELLO_SSLV2)
{
state->hash.update(static_cast<byte>(type));
const size_t record_length = contents.size();
for(size_t i = 0; i != 3; i++)
state->hash.update(get_byte<u32bit>(i+1, record_length));
}
state->hash.update(contents);
}
if(type == CLIENT_HELLO || type == CLIENT_HELLO_SSLV2)
{
server_check_state(type, state);
state->client_hello = new Client_Hello(contents, type);
client_requested_hostname = state->client_hello->hostname();
state->version = choose_version(state->client_hello->version(),
policy.min_version());
writer.set_version(state->version);
reader.set_version(state->version);
state->server_hello = new Server_Hello(rng, writer,
policy, cert_chain,
*(state->client_hello),
state->version, state->hash);
state->suite = CipherSuite(state->server_hello->ciphersuite());
if(state->suite.sig_type() != TLS_ALGO_SIGNER_ANON)
{
// FIXME: should choose certs based on sig type
state->server_certs = new Certificate(writer, cert_chain,
state->hash);
}
state->kex_priv = PKCS8::copy_key(*private_key, rng);
if(state->suite.kex_type() != TLS_ALGO_KEYEXCH_NOKEX)
{
if(state->suite.kex_type() == TLS_ALGO_KEYEXCH_RSA)
{
state->kex_priv = new RSA_PrivateKey(rng,
policy.rsa_export_keysize());
}
else if(state->suite.kex_type() == TLS_ALGO_KEYEXCH_DH)
{
state->kex_priv = new DH_PrivateKey(rng, policy.dh_group());
}
else
throw Internal_Error("TLS_Server: Unknown ciphersuite kex type");
state->server_kex =
new Server_Key_Exchange(rng, writer,
state->kex_priv, private_key,
state->client_hello->random(),
state->server_hello->random(),
state->hash);
}
if(policy.require_client_auth())
{
state->do_client_auth = true;
throw Internal_Error("Client auth not implemented");
// FIXME: send client auth request here
}
state->server_hello_done = new Server_Hello_Done(writer, state->hash);
}
else if(type == CERTIFICATE)
{
server_check_state(type, state);
// FIXME: process this
}
else if(type == CLIENT_KEX)
{
server_check_state(type, state);
state->client_kex = new Client_Key_Exchange(contents, state->suite,
state->version);
SecureVector<byte> pre_master =
state->client_kex->pre_master_secret(rng, state->kex_priv,
state->server_hello->version());
state->keys = SessionKeys(state->suite, state->version, pre_master,
state->client_hello->random(),
state->server_hello->random());
}
else if(type == CERTIFICATE_VERIFY)
{
server_check_state(type, state);
// FIXME: process this
}
else if(type == HANDSHAKE_CCS)
{
server_check_state(type, state);
reader.set_keys(state->suite, state->keys, SERVER);
state->got_client_ccs = true;
}
else if(type == FINISHED)
{
server_check_state(type, state);
state->client_finished = new Finished(contents);
if(!state->client_finished->verify(state->keys.master_secret(),
state->version, state->hash, CLIENT))
throw TLS_Exception(DECRYPT_ERROR,
"Finished message didn't verify");
state->hash.update(static_cast<byte>(type));
const size_t record_length = contents.size();
for(size_t i = 0; i != 3; i++)
state->hash.update(get_byte<u32bit>(i+1, record_length));
state->hash.update(contents);
writer.send(CHANGE_CIPHER_SPEC, 1);
writer.flush();
writer.set_keys(state->suite, state->keys, SERVER);
state->server_finished = new Finished(writer, state->version, SERVER,
state->keys.master_secret(),
state->hash);
delete state;
state = 0;
active = true;
}
else
throw Unexpected_Message("Unknown handshake message received");
}
/*
* Create a new Client Key Exchange message
*/
Client_Key_Exchange::Client_Key_Exchange(Handshake_IO& io,
Handshake_State& state,
const Policy& policy,
Credentials_Manager& creds,
const Public_Key* server_public_key,
const std::string& hostname,
RandomNumberGenerator& rng)
{
const std::string kex_algo = state.ciphersuite().kex_algo();
if(kex_algo == "PSK")
{
std::string identity_hint = "";
if(state.server_kex())
{
TLS_Data_Reader reader("ClientKeyExchange", state.server_kex()->params());
identity_hint = reader.get_string(2, 0, 65535);
}
const std::string psk_identity = creds.psk_identity("tls-client",
hostname,
identity_hint);
append_tls_length_value(m_key_material, psk_identity, 2);
SymmetricKey psk = creds.psk("tls-client", hostname, psk_identity);
std::vector<byte> zeros(psk.length());
append_tls_length_value(m_pre_master, zeros, 2);
append_tls_length_value(m_pre_master, psk.bits_of(), 2);
}
else if(state.server_kex())
{
TLS_Data_Reader reader("ClientKeyExchange", state.server_kex()->params());
SymmetricKey psk;
if(kex_algo == "DHE_PSK" || kex_algo == "ECDHE_PSK")
{
std::string identity_hint = reader.get_string(2, 0, 65535);
const std::string psk_identity = creds.psk_identity("tls-client",
hostname,
identity_hint);
append_tls_length_value(m_key_material, psk_identity, 2);
psk = creds.psk("tls-client", hostname, psk_identity);
}
if(kex_algo == "DH" || kex_algo == "DHE_PSK")
{
BigInt p = BigInt::decode(reader.get_range<byte>(2, 1, 65535));
BigInt g = BigInt::decode(reader.get_range<byte>(2, 1, 65535));
BigInt Y = BigInt::decode(reader.get_range<byte>(2, 1, 65535));
if(reader.remaining_bytes())
throw Decoding_Error("Bad params size for DH key exchange");
if(p.bits() < policy.minimum_dh_group_size())
throw TLS_Exception(Alert::INSUFFICIENT_SECURITY,
"Server sent DH group of " +
std::to_string(p.bits()) +
" bits, policy requires at least " +
std::to_string(policy.minimum_dh_group_size()));
/*
* A basic check for key validity. As we do not know q here we
* cannot check that Y is in the right subgroup. However since
* our key is ephemeral there does not seem to be any
* advantage to bogus keys anyway.
*/
if(Y <= 1 || Y >= p - 1)
throw TLS_Exception(Alert::INSUFFICIENT_SECURITY,
"Server sent bad DH key for DHE exchange");
DL_Group group(p, g);
if(!group.verify_group(rng, false))
throw TLS_Exception(Alert::INSUFFICIENT_SECURITY,
"DH group validation failed");
DH_PublicKey counterparty_key(group, Y);
DH_PrivateKey priv_key(rng, group);
PK_Key_Agreement ka(priv_key, "Raw");
secure_vector<byte> dh_secret = CT::strip_leading_zeros(
ka.derive_key(0, counterparty_key.public_value()).bits_of());
if(kex_algo == "DH")
m_pre_master = dh_secret;
else
{
append_tls_length_value(m_pre_master, dh_secret, 2);
append_tls_length_value(m_pre_master, psk.bits_of(), 2);
}
append_tls_length_value(m_key_material, priv_key.public_value(), 2);
}
else if(kex_algo == "ECDH" || kex_algo == "ECDHE_PSK")
{
const byte curve_type = reader.get_byte();
if(curve_type != 3)
throw Decoding_Error("Server sent non-named ECC curve");
const u16bit curve_id = reader.get_u16bit();
const std::string name = Supported_Elliptic_Curves::curve_id_to_name(curve_id);
if(name == "")
throw Decoding_Error("Server sent unknown named curve " + std::to_string(curve_id));
EC_Group group(name);
std::vector<byte> ecdh_key = reader.get_range<byte>(1, 1, 255);
ECDH_PublicKey counterparty_key(group, OS2ECP(ecdh_key, group.get_curve()));
ECDH_PrivateKey priv_key(rng, group);
PK_Key_Agreement ka(priv_key, "Raw");
secure_vector<byte> ecdh_secret =
ka.derive_key(0, counterparty_key.public_value()).bits_of();
if(kex_algo == "ECDH")
m_pre_master = ecdh_secret;
else
{
append_tls_length_value(m_pre_master, ecdh_secret, 2);
append_tls_length_value(m_pre_master, psk.bits_of(), 2);
}
append_tls_length_value(m_key_material, priv_key.public_value(), 1);
}
#if defined(BOTAN_HAS_SRP6)
else if(kex_algo == "SRP_SHA")
{
const BigInt N = BigInt::decode(reader.get_range<byte>(2, 1, 65535));
const BigInt g = BigInt::decode(reader.get_range<byte>(2, 1, 65535));
std::vector<byte> salt = reader.get_range<byte>(1, 1, 255);
const BigInt B = BigInt::decode(reader.get_range<byte>(2, 1, 65535));
const std::string srp_group = srp6_group_identifier(N, g);
const std::string srp_identifier =
creds.srp_identifier("tls-client", hostname);
const std::string srp_password =
creds.srp_password("tls-client", hostname, srp_identifier);
std::pair<BigInt, SymmetricKey> srp_vals =
srp6_client_agree(srp_identifier,
srp_password,
srp_group,
"SHA-1",
salt,
B,
rng);
append_tls_length_value(m_key_material, BigInt::encode(srp_vals.first), 2);
m_pre_master = srp_vals.second.bits_of();
}
#endif
else
{
throw Internal_Error("Client_Key_Exchange: Unknown kex " +
kex_algo);
}
reader.assert_done();
}
else
{
// No server key exchange msg better mean RSA kex + RSA key in cert
if(kex_algo != "RSA")
throw Unexpected_Message("No server kex but negotiated kex " + kex_algo);
if(!server_public_key)
throw Internal_Error("No server public key for RSA exchange");
if(auto rsa_pub = dynamic_cast<const RSA_PublicKey*>(server_public_key))
{
const Protocol_Version offered_version = state.client_hello()->version();
m_pre_master = rng.random_vec(48);
m_pre_master[0] = offered_version.major_version();
m_pre_master[1] = offered_version.minor_version();
PK_Encryptor_EME encryptor(*rsa_pub, "PKCS1v15");
const std::vector<byte> encrypted_key = encryptor.encrypt(m_pre_master, rng);
append_tls_length_value(m_key_material, encrypted_key, 2);
}
else
throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
"Expected a RSA key in server cert but got " +
server_public_key->algo_name());
}
state.hash().update(io.send(*this));
}
/*
* Read a Client Key Exchange message
*/
Client_Key_Exchange::Client_Key_Exchange(const std::vector<byte>& contents,
const Handshake_State& state,
const Private_Key* server_rsa_kex_key,
Credentials_Manager& creds,
const Policy& policy,
RandomNumberGenerator& rng)
{
const std::string kex_algo = state.ciphersuite().kex_algo();
if(kex_algo == "RSA")
{
BOTAN_ASSERT(state.server_certs() && !state.server_certs()->cert_chain().empty(),
"RSA key exchange negotiated so server sent a certificate");
if(!server_rsa_kex_key)
throw Internal_Error("Expected RSA kex but no server kex key set");
if(!dynamic_cast<const RSA_PrivateKey*>(server_rsa_kex_key))
throw Internal_Error("Expected RSA key but got " + server_rsa_kex_key->algo_name());
PK_Decryptor_EME decryptor(*server_rsa_kex_key, "PKCS1v15");
Protocol_Version client_version = state.client_hello()->version();
/*
* This is used as the pre-master if RSA decryption fails.
* Otherwise we can be used as an oracle. See Bleichenbacher
* "Chosen Ciphertext Attacks against Protocols Based on RSA
* Encryption Standard PKCS #1", Crypto 98
*
* Create it here instead if in the catch clause as otherwise we
* expose a timing channel WRT the generation of the fake value.
* Some timing channel likely remains due to exception handling
* and the like.
*/
secure_vector<byte> fake_pre_master = rng.random_vec(48);
fake_pre_master[0] = client_version.major_version();
fake_pre_master[1] = client_version.minor_version();
try
{
TLS_Data_Reader reader("ClientKeyExchange", contents);
m_pre_master = decryptor.decrypt(reader.get_range<byte>(2, 0, 65535));
if(m_pre_master.size() != 48 ||
client_version.major_version() != m_pre_master[0] ||
client_version.minor_version() != m_pre_master[1])
{
throw Decoding_Error("Client_Key_Exchange: Secret corrupted");
}
}
catch(...)
{
m_pre_master = fake_pre_master;
}
}
else
{
TLS_Data_Reader reader("ClientKeyExchange", contents);
SymmetricKey psk;
if(kex_algo == "PSK" || kex_algo == "DHE_PSK" || kex_algo == "ECDHE_PSK")
{
const std::string psk_identity = reader.get_string(2, 0, 65535);
psk = creds.psk("tls-server",
state.client_hello()->sni_hostname(),
psk_identity);
if(psk.length() == 0)
{
if(policy.hide_unknown_users())
psk = SymmetricKey(rng, 16);
else
throw TLS_Exception(Alert::UNKNOWN_PSK_IDENTITY,
"No PSK for identifier " + psk_identity);
}
}
if(kex_algo == "PSK")
{
std::vector<byte> zeros(psk.length());
append_tls_length_value(m_pre_master, zeros, 2);
append_tls_length_value(m_pre_master, psk.bits_of(), 2);
}
#if defined(BOTAN_HAS_SRP6)
else if(kex_algo == "SRP_SHA")
{
SRP6_Server_Session& srp = state.server_kex()->server_srp_params();
m_pre_master = srp.step2(BigInt::decode(reader.get_range<byte>(2, 0, 65535))).bits_of();
}
#endif
else if(kex_algo == "DH" || kex_algo == "DHE_PSK" ||
kex_algo == "ECDH" || kex_algo == "ECDHE_PSK")
{
const Private_Key& private_key = state.server_kex()->server_kex_key();
const PK_Key_Agreement_Key* ka_key =
dynamic_cast<const PK_Key_Agreement_Key*>(&private_key);
if(!ka_key)
throw Internal_Error("Expected key agreement key type but got " +
private_key.algo_name());
try
{
PK_Key_Agreement ka(*ka_key, "Raw");
std::vector<byte> client_pubkey;
if(ka_key->algo_name() == "DH")
client_pubkey = reader.get_range<byte>(2, 0, 65535);
else
client_pubkey = reader.get_range<byte>(1, 0, 255);
secure_vector<byte> shared_secret = ka.derive_key(0, client_pubkey).bits_of();
if(ka_key->algo_name() == "DH")
shared_secret = CT::strip_leading_zeros(shared_secret);
if(kex_algo == "DHE_PSK" || kex_algo == "ECDHE_PSK")
{
append_tls_length_value(m_pre_master, shared_secret, 2);
append_tls_length_value(m_pre_master, psk.bits_of(), 2);
}
else
m_pre_master = shared_secret;
}
catch(std::exception &)
{
/*
* Something failed in the DH computation. To avoid possible
* timing attacks, randomize the pre-master output and carry
* on, allowing the protocol to fail later in the finished
* checks.
*/
m_pre_master = rng.random_vec(ka_key->public_value().size());
}
}
else
throw Internal_Error("Client_Key_Exchange: Unknown kex type " + kex_algo);
}
}
/**
* Create a new Server Key Exchange message
*/
Server_Key_Exchange::Server_Key_Exchange(Handshake_IO& io,
Handshake_State& state,
const Policy& policy,
Credentials_Manager& creds,
RandomNumberGenerator& rng,
const Private_Key* signing_key)
{
const std::string hostname = state.client_hello()->sni_hostname();
const Kex_Algo kex_algo = state.ciphersuite().kex_method();
if(kex_algo == Kex_Algo::PSK || kex_algo == Kex_Algo::DHE_PSK || kex_algo == Kex_Algo::ECDHE_PSK)
{
std::string identity_hint =
creds.psk_identity_hint("tls-server", hostname);
append_tls_length_value(m_params, identity_hint, 2);
}
if(kex_algo == Kex_Algo::DH || kex_algo == Kex_Algo::DHE_PSK)
{
const std::vector<Group_Params> dh_groups = state.client_hello()->supported_dh_groups();
Group_Params shared_group = Group_Params::NONE;
/*
If the client does not send any DH groups in the supported groups
extension, but does offer DH ciphersuites, we select a group arbitrarily
*/
if(dh_groups.empty())
{
shared_group = policy.default_dh_group();
}
else
{
shared_group = policy.choose_key_exchange_group(dh_groups);
}
if(shared_group == Group_Params::NONE)
throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
"Could not agree on a DH group with the client");
BOTAN_ASSERT(group_param_is_dh(shared_group), "DH groups for the DH ciphersuites god");
const std::string group_name = state.callbacks().tls_decode_group_param(shared_group);
std::unique_ptr<DH_PrivateKey> dh(new DH_PrivateKey(rng, DL_Group(group_name)));
append_tls_length_value(m_params, BigInt::encode(dh->get_domain().get_p()), 2);
append_tls_length_value(m_params, BigInt::encode(dh->get_domain().get_g()), 2);
append_tls_length_value(m_params, dh->public_value(), 2);
m_kex_key.reset(dh.release());
}
else if(kex_algo == Kex_Algo::ECDH || kex_algo == Kex_Algo::ECDHE_PSK)
{
const std::vector<Group_Params> ec_groups = state.client_hello()->supported_ecc_curves();
if(ec_groups.empty())
throw Internal_Error("Client sent no ECC extension but we negotiated ECDH");
Group_Params shared_group = policy.choose_key_exchange_group(ec_groups);
if(shared_group == Group_Params::NONE)
throw TLS_Exception(Alert::HANDSHAKE_FAILURE, "No shared ECC group with client");
std::vector<uint8_t> ecdh_public_val;
if(shared_group == Group_Params::X25519)
{
#if defined(BOTAN_HAS_CURVE_25519)
std::unique_ptr<Curve25519_PrivateKey> x25519(new Curve25519_PrivateKey(rng));
ecdh_public_val = x25519->public_value();
m_kex_key.reset(x25519.release());
#else
throw Internal_Error("Negotiated X25519 somehow, but it is disabled");
#endif
}
else
{
Group_Params curve = policy.choose_key_exchange_group(ec_groups);
const std::string curve_name = state.callbacks().tls_decode_group_param(curve);
EC_Group ec_group(curve_name);
std::unique_ptr<ECDH_PrivateKey> ecdh(new ECDH_PrivateKey(rng, ec_group));
// follow client's preference for point compression
ecdh_public_val = ecdh->public_value(
state.client_hello()->prefers_compressed_ec_points() ?
PointGFp::COMPRESSED : PointGFp::UNCOMPRESSED);
m_kex_key.reset(ecdh.release());
}
const uint16_t named_curve_id = static_cast<uint16_t>(shared_group);
m_params.push_back(3); // named curve
m_params.push_back(get_byte(0, named_curve_id));
m_params.push_back(get_byte(1, named_curve_id));
append_tls_length_value(m_params, ecdh_public_val, 1);
}
#if defined(BOTAN_HAS_SRP6)
else if(kex_algo == Kex_Algo::SRP_SHA)
{
const std::string srp_identifier = state.client_hello()->srp_identifier();
std::string group_id;
BigInt v;
std::vector<uint8_t> salt;
const bool found = creds.srp_verifier("tls-server", hostname,
srp_identifier,
group_id, v, salt,
policy.hide_unknown_users());
if(!found)
throw TLS_Exception(Alert::UNKNOWN_PSK_IDENTITY,
"Unknown SRP user " + srp_identifier);
m_srp_params.reset(new SRP6_Server_Session);
BigInt B = m_srp_params->step1(v, group_id,
"SHA-1", rng);
DL_Group group(group_id);
append_tls_length_value(m_params, BigInt::encode(group.get_p()), 2);
append_tls_length_value(m_params, BigInt::encode(group.get_g()), 2);
append_tls_length_value(m_params, salt, 1);
append_tls_length_value(m_params, BigInt::encode(B), 2);
}
#endif
#if defined(BOTAN_HAS_CECPQ1)
else if(kex_algo == Kex_Algo::CECPQ1)
{
std::vector<uint8_t> cecpq1_offer(CECPQ1_OFFER_BYTES);
m_cecpq1_key.reset(new CECPQ1_key);
CECPQ1_offer(cecpq1_offer.data(), m_cecpq1_key.get(), rng);
append_tls_length_value(m_params, cecpq1_offer, 2);
}
#endif
else if(kex_algo != Kex_Algo::PSK)
{
throw Internal_Error("Server_Key_Exchange: Unknown kex type " +
kex_method_to_string(kex_algo));
}
if(state.ciphersuite().signature_used())
{
BOTAN_ASSERT(signing_key, "Signing key was set");
std::pair<std::string, Signature_Format> format =
state.choose_sig_format(*signing_key, m_scheme, false, policy);
std::vector<uint8_t> buf = state.client_hello()->random();
buf += state.server_hello()->random();
buf += params();
m_signature =
state.callbacks().tls_sign_message(*signing_key, rng,
format.first, format.second, buf);
}
state.hash().update(io.send(*this));
}
std::pair<std::string, Signature_Format>
Handshake_State::parse_sig_format(const Public_Key& key,
const std::string& input_hash_algo,
const std::string& input_sig_algo,
bool for_client_auth,
const Policy& policy) const
{
const std::string key_type = key.algo_name();
if(!policy.allowed_signature_method(key_type))
{
throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
"Rejecting " + key_type + " signature");
}
std::string hash_algo;
if(this->version().supports_negotiable_signature_algorithms())
{
if(input_sig_algo != key_type)
throw Decoding_Error("Counterparty sent inconsistent key and sig types");
if(input_hash_algo == "")
throw Decoding_Error("Counterparty did not send hash/sig IDS");
hash_algo = input_hash_algo;
if(for_client_auth && !cert_req())
{
throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
"No certificate verify set");
}
/*
Confirm the signature type we just received against the
supported_algos list that we sent; it better be there.
*/
const auto supported_algos =
for_client_auth ? cert_req()->supported_algos() :
client_hello()->supported_algos();
if(!supported_algos_include(supported_algos, key_type, hash_algo))
{
throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
"TLS signature extension did not allow for " +
key_type + "/" + hash_algo + " signature");
}
}
else
{
if(input_hash_algo != "" || input_sig_algo != "")
throw Decoding_Error("Counterparty sent hash/sig IDs with old version");
if(key_type == "RSA")
{
hash_algo = "Parallel(MD5,SHA-160)";
}
else if(key_type == "DSA" || key_type == "ECDSA")
{
hash_algo = "SHA-1";
}
else
{
throw Invalid_Argument(key_type + " is invalid/unknown for TLS signatures");
}
/*
There is no check on the acceptability of a v1.0/v1.1 hash type,
since it's implicit with use of the protocol
*/
}
if(key_type == "RSA")
{
const std::string padding = "EMSA3(" + hash_algo + ")";
return std::make_pair(padding, IEEE_1363);
}
else if(key_type == "DSA" || key_type == "ECDSA")
{
const std::string padding = "EMSA1(" + hash_algo + ")";
return std::make_pair(padding, DER_SEQUENCE);
}
throw Invalid_Argument(key_type + " is invalid/unknown for TLS signatures");
}
/**
* Create a new Server Key Exchange message
*/
Server_Key_Exchange::Server_Key_Exchange(Handshake_IO& io,
Handshake_State& state,
const Policy& policy,
Credentials_Manager& creds,
RandomNumberGenerator& rng,
const Private_Key* signing_key)
{
const std::string hostname = state.client_hello()->sni_hostname();
const std::string kex_algo = state.ciphersuite().kex_algo();
if(kex_algo == "PSK" || kex_algo == "DHE_PSK" || kex_algo == "ECDHE_PSK")
{
std::string identity_hint =
creds.psk_identity_hint("tls-server", hostname);
append_tls_length_value(m_params, identity_hint, 2);
}
if(kex_algo == "DH" || kex_algo == "DHE_PSK")
{
std::unique_ptr<DH_PrivateKey> dh(new DH_PrivateKey(rng, DL_Group(policy.dh_group())));
append_tls_length_value(m_params, BigInt::encode(dh->get_domain().get_p()), 2);
append_tls_length_value(m_params, BigInt::encode(dh->get_domain().get_g()), 2);
append_tls_length_value(m_params, dh->public_value(), 2);
m_kex_key.reset(dh.release());
}
else if(kex_algo == "ECDH" || kex_algo == "ECDHE_PSK")
{
const std::vector<std::string>& curves =
state.client_hello()->supported_ecc_curves();
if(curves.empty())
throw Internal_Error("Client sent no ECC extension but we negotiated ECDH");
const std::string curve_name = policy.choose_curve(curves);
if(curve_name == "")
throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
"Could not agree on an ECC curve with the client");
EC_Group ec_group(curve_name);
std::unique_ptr<ECDH_PrivateKey> ecdh(new ECDH_PrivateKey(rng, ec_group));
const std::string ecdh_domain_oid = ecdh->domain().get_oid();
const std::string domain = OIDS::lookup(OID(ecdh_domain_oid));
if(domain == "")
throw Internal_Error("Could not find name of ECDH domain " + ecdh_domain_oid);
const u16bit named_curve_id = Supported_Elliptic_Curves::name_to_curve_id(domain);
m_params.push_back(3); // named curve
m_params.push_back(get_byte(0, named_curve_id));
m_params.push_back(get_byte(1, named_curve_id));
append_tls_length_value(m_params, ecdh->public_value(), 1);
m_kex_key.reset(ecdh.release());
}
#if defined(BOTAN_HAS_SRP6)
else if(kex_algo == "SRP_SHA")
{
const std::string srp_identifier = state.client_hello()->srp_identifier();
std::string group_id;
BigInt v;
std::vector<byte> salt;
const bool found = creds.srp_verifier("tls-server", hostname,
srp_identifier,
group_id, v, salt,
policy.hide_unknown_users());
if(!found)
throw TLS_Exception(Alert::UNKNOWN_PSK_IDENTITY,
"Unknown SRP user " + srp_identifier);
m_srp_params.reset(new SRP6_Server_Session);
BigInt B = m_srp_params->step1(v, group_id,
"SHA-1", rng);
DL_Group group(group_id);
append_tls_length_value(m_params, BigInt::encode(group.get_p()), 2);
append_tls_length_value(m_params, BigInt::encode(group.get_g()), 2);
append_tls_length_value(m_params, salt, 1);
append_tls_length_value(m_params, BigInt::encode(B), 2);
}
#endif
else if(kex_algo != "PSK")
throw Internal_Error("Server_Key_Exchange: Unknown kex type " + kex_algo);
if(state.ciphersuite().sig_algo() != "")
{
BOTAN_ASSERT(signing_key, "Signing key was set");
std::pair<std::string, Signature_Format> format =
state.choose_sig_format(*signing_key, m_hash_algo, m_sig_algo, false, policy);
PK_Signer signer(*signing_key, format.first, format.second);
signer.update(state.client_hello()->random());
signer.update(state.server_hello()->random());
signer.update(params());
m_signature = signer.signature(rng);
}
state.hash().update(io.send(*this));
}