Repository: randombit/botan
Pull request #3152 (2023-01-01 21:47:24)

Rename PointGFp to EC_Point
The former name suggests support for GF(2^m) curves either existing or possibly existing in the future. Since such curves are difficult to implement in software and possibly are entirely broken, there doesn't seem to be much call for this.


Patch:
diff --git a/doc/api_ref/ecc.rst b/doc/api_ref/ecc.rst
index f522bbe3d..2af2ef2cd 100644
--- a/doc/api_ref/ecc.rst
+++ b/doc/api_ref/ecc.rst
@@ -88,7 +88,7 @@ during common operations.
 
          Return the ``b`` parameter of the elliptic curve equation.
 
-      .. cpp:function:: const PointGFp& get_base_point() const
+      .. cpp:function:: const EC_Point& get_base_point() const
 
          Return the groups base point element.
 
@@ -120,7 +120,7 @@ during common operations.
 
          Multiply ``x`` and ``y`` and reduce the result modulo the curve order.
 
-      .. cpp:function:: bool verify_public_element(const PointGFp& y) const
+      .. cpp:function:: bool verify_public_element(const EC_Point& y) const
 
          Return true if ``y`` seems to be a valid group element.
 
@@ -128,18 +128,18 @@ during common operations.
 
          Return the OID used to identify the curve. May be empty.
 
-      .. cpp:function:: PointGFp point(const BigInt& x, const BigInt& y) const
+      .. cpp:function:: EC_Point point(const BigInt& x, const BigInt& y) const
 
          Create and return a point with affine elements ``x`` and ``y``. Note
          this function *does not* verify that ``x`` and ``y`` satisfy the curve
          equation.
 
-      .. cpp:function:: PointGFp point_multiply(const BigInt& x, const PointGFp& pt, const BigInt& y) const
+      .. cpp:function:: EC_Point point_multiply(const BigInt& x, const EC_Point& pt, const BigInt& y) const
 
          Multi-exponentiation. Returns base_point*x + pt*y. Not constant time.
          (Ordinarily used for signature verification.)
 
-      .. cpp:function:: PointGFp blinded_base_point_multiply(const BigInt& k, \
+      .. cpp:function:: EC_Point blinded_base_point_multiply(const BigInt& k, \
                                             RandomNumberGenerator& rng, \
                                             std::vector<BigInt>& ws) const
 
@@ -151,7 +151,7 @@ during common operations.
 
          Like `blinded_base_point_multiply` but returns only the x coordinate.
 
-      .. cpp:function:: PointGFp blinded_var_point_multiply(const PointGFp& point, \
+      .. cpp:function:: EC_Point blinded_var_point_multiply(const EC_Point& point, \
                                           const BigInt& k, \
                                           RandomNumberGenerator& rng, \
                                           std::vector<BigInt>& ws) const
@@ -162,11 +162,11 @@ during common operations.
 
          Return a random scalar (ie an integer between 1 and the group order).
 
-      .. cpp:function:: PointGFp zero_point() const
+      .. cpp:function:: EC_Point zero_point() const
 
          Return the zero point (aka the point at infinity).
 
-      .. cpp:function:: PointGFp OS2ECP(const uint8_t bits[], size_t len) const
+      .. cpp:function:: EC_Point OS2ECP(const uint8_t bits[], size_t len) const
 
          Decode a point from the binary encoding. This function verifies that
          the decoded point is a valid element on the curve.
@@ -180,30 +180,30 @@ during common operations.
          Return a list of known groups, ie groups for which ``EC_Group(name)``
          will succeed.
 
-.. cpp:class:: PointGFp
+.. cpp:class:: EC_Point
 
    Stores elliptic curve points in Jacobian representation.
 
-   .. cpp:function:: std::vector<uint8_t> encode(PointGFp::Compression_Type format) const
+   .. cpp:function:: std::vector<uint8_t> encode(EC_Point::Compression_Type format) const
 
       Encode a point in a way that can later be decoded with `EC_Group::OS2ECP`.
 
-   .. cpp:function:: PointGFp& operator+=(const PointGFp& rhs)
+   .. cpp:function:: EC_Point& operator+=(const EC_Point& rhs)
 
       Point addition.
 
-   .. cpp:function:: PointGFp& operator-=(const PointGFp& rhs)
+   .. cpp:function:: EC_Point& operator-=(const EC_Point& rhs)
 
       Point subtraction.
 
-   .. cpp:function:: PointGFp& operator*=(const BigInt& scalar)
+   .. cpp:function:: EC_Point& operator*=(const BigInt& scalar)
 
       Point multiplication using Montgomery ladder.
 
       .. warning::
          Prefer the blinded functions in ``EC_Group``
 
-   .. cpp:function:: PointGFp& negate()
+   .. cpp:function:: EC_Point& negate()
 
       Negate this point.
 
@@ -220,7 +220,7 @@ during common operations.
       Convert the point to its equivalent affine coordinates. Throws
       if this is the point at infinity.
 
-   .. cpp:function:: static void force_all_affine(std::vector<PointGFp>& points, \
+   .. cpp:function:: static void force_all_affine(std::vector<EC_Point>& points, \
                                                   secure_vector<word>& ws)
 
       Force several points to be affine at once. Uses Montgomery's
@@ -243,15 +243,15 @@ during common operations.
 
       Randomize the point representation.
 
-   .. cpp:function:: bool operator==(const PointGFp& other) const
+   .. cpp:function:: bool operator==(const EC_Point& other) const
 
       Point equality. This compares the affine representations.
 
-   .. cpp:function:: void add(const PointGFp& other, std::vector<BigInt>& workspace)
+   .. cpp:function:: void add(const EC_Point& other, std::vector<BigInt>& workspace)
 
       Point addition, taking a workspace.
 
-   .. cpp:function:: void add_affine(const PointGFp& other, std::vector<BigInt>& workspace)
+   .. cpp:function:: void add_affine(const EC_Point& other, std::vector<BigInt>& workspace)
 
       Mixed (Jacobian+affine) addition, taking a workspace.
 
@@ -268,15 +268,15 @@ during common operations.
 
       Repeated point doubling.
 
-   .. cpp:function:: PointGFp plus(const PointGFp& other, std::vector<BigInt>& workspace) const
+   .. cpp:function:: EC_Point plus(const EC_Point& other, std::vector<BigInt>& workspace) const
 
       Point addition, returning the result.
 
-   .. cpp:function:: PointGFp double_of(std::vector<BigInt>& workspace) const
+   .. cpp:function:: EC_Point double_of(std::vector<BigInt>& workspace) const
 
       Point doubling, returning the result.
 
-   .. cpp:function:: PointGFp zero() const
+   .. cpp:function:: EC_Point zero() const
 
       Return the point at infinity
 
diff --git a/doc/side_channels.rst b/doc/side_channels.rst
index c394e5633..1ed5fe4d6 100644
--- a/doc/side_channels.rst
+++ b/doc/side_channels.rst
@@ -154,17 +154,17 @@ ECC point decoding
 The API function OS2ECP, which is used to convert byte strings to ECC points,
 verifies that all points satisfy the ECC curve equation. Points that do not
 satisfy the equation are invalid, and can sometimes be used to break
-protocols ([InvalidCurve] [InvalidCurveTLS]). See point_gfp.cpp.
+protocols ([InvalidCurve] [InvalidCurveTLS]). See ec_point.cpp.
 
 ECC scalar multiply
 ----------------------
 
 There are several different implementations of ECC scalar multiplications which
-depend on the API invoked. This include ``PointGFp::operator*``,
+depend on the API invoked. This include ``EC_Point::operator*``,
 ``EC_Group::blinded_base_point_multiply`` and
 ``EC_Group::blinded_var_point_multiply``.
 
-The ``PointGFp::operator*`` implementation uses the Montgomery ladder, which is
+The ``EC_Point::operator*`` implementation uses the Montgomery ladder, which is
 fairly resistant to side channels. However it leaks the size of the scalar,
 because the loop iterations are bounded by the scalar size. It should not be
 used in cases when the scalar is a secret.
@@ -200,7 +200,7 @@ points. The table of precomputed multiples is accessed using a masked lookup
 which should not leak information about the secret scalar to an attacker who can
 mount a cache-based side channel attack.
 
-See point_gfp.cpp and point_mul.cpp
+See ec_point.cpp and point_mul.cpp in src/lib/pubkey/ec_group
 
 ECDH
 ----------------------
diff --git a/src/cli/speed.cpp b/src/cli/speed.cpp
index b2c22326e..2fa7cf374 100644
--- a/src/cli/speed.cpp
+++ b/src/cli/speed.cpp
@@ -1139,14 +1139,14 @@ class Speed final : public Command
             auto addf_timer = make_timer(group_name + " addf");
             auto dbl_timer = make_timer(group_name + " dbl");
 
-            const Botan::PointGFp& base_point = ec_group.get_base_point();
+            const Botan::EC_Point& base_point = ec_group.get_base_point();
 
             // create a non-affine point
             const auto random_k = Botan::BigInt::from_u64(0x4E6F537465707E);
-            Botan::PointGFp non_affine_pt = ec_group.get_base_point() * random_k;
-            Botan::PointGFp pt = ec_group.get_base_point();
+            Botan::EC_Point non_affine_pt = ec_group.get_base_point() * random_k;
+            Botan::EC_Point pt = ec_group.get_base_point();
 
-            std::vector<Botan::BigInt> ws(Botan::PointGFp::WORKSPACE_SIZE);
+            std::vector<Botan::BigInt> ws(Botan::EC_Point::WORKSPACE_SIZE);
 
             while(add_timer->under(runtime) && addf_timer->under(runtime) && dbl_timer->under(runtime))
                {
@@ -1187,7 +1187,7 @@ class Speed final : public Command
             auto blinded_mult_timer = make_timer(group_name + " blinded comb");
             auto blinded_var_mult_timer = make_timer(group_name + " blinded window");
 
-            const Botan::PointGFp& base_point = ec_group.get_base_point();
+            const Botan::EC_Point& base_point = ec_group.get_base_point();
 
             std::vector<Botan::BigInt> ws;
 
@@ -1197,12 +1197,12 @@ class Speed final : public Command
                {
                const Botan::BigInt scalar(rng(), ec_group.get_p_bits());
 
-               const Botan::PointGFp r1 = mult_timer->run([&]() { return base_point * scalar; });
+               const Botan::EC_Point r1 = mult_timer->run([&]() { return base_point * scalar; });
 
-               const Botan::PointGFp r2 = blinded_mult_timer->run(
+               const Botan::EC_Point r2 = blinded_mult_timer->run(
                   [&]() { return ec_group.blinded_base_point_multiply(scalar, rng(), ws); });
 
-               const Botan::PointGFp r3 = blinded_var_mult_timer->run(
+               const Botan::EC_Point r3 = blinded_var_mult_timer->run(
                   [&]() { return ec_group.blinded_var_point_multiply(base_point, scalar, rng(), ws); });
 
                BOTAN_ASSERT_EQUAL(r1, r2, "Same point computed by Montgomery and comb");
@@ -1227,9 +1227,9 @@ class Speed final : public Command
             while(uncmp_timer->under(runtime) && cmp_timer->under(runtime))
                {
                const Botan::BigInt k(rng(), 256);
-               const Botan::PointGFp p = ec_group.get_base_point() * k;
-               const std::vector<uint8_t> os_cmp = p.encode(Botan::PointGFp::COMPRESSED);
-               const std::vector<uint8_t> os_uncmp = p.encode(Botan::PointGFp::UNCOMPRESSED);
+               const Botan::EC_Point p = ec_group.get_base_point() * k;
+               const std::vector<uint8_t> os_cmp = p.encode(Botan::EC_Point::COMPRESSED);
+               const std::vector<uint8_t> os_uncmp = p.encode(Botan::EC_Point::UNCOMPRESSED);
 
                uncmp_timer->run([&]() { ec_group.OS2ECP(os_uncmp); });
                cmp_timer->run([&]() { ec_group.OS2ECP(os_cmp); });
@@ -1258,13 +1258,13 @@ class Speed final : public Command
 
                rng().randomize(input.data(), input.size());
 
-               const Botan::PointGFp p1 = h2c_ro_timer->run([&]() {
+               const Botan::EC_Point p1 = h2c_ro_timer->run([&]() {
                   return group.hash_to_curve("SHA-256", input.data(), input.size(), nullptr, 0, true);
                   });
 
                BOTAN_ASSERT_NOMSG(p1.on_the_curve());
 
-               const Botan::PointGFp p2 = h2c_nu_timer->run([&]() {
+               const Botan::EC_Point p2 = h2c_nu_timer->run([&]() {
                   return group.hash_to_curve("SHA-256", input.data(), input.size(), nullptr, 0, false);
                   });
 
diff --git a/src/examples/pkcs11_ecdh.cpp b/src/examples/pkcs11_ecdh.cpp
index 52c551ef5..b5cb84259 100644
--- a/src/examples/pkcs11_ecdh.cpp
+++ b/src/examples/pkcs11_ecdh.cpp
@@ -55,7 +55,7 @@ int main() {
   // set import properties
   std::vector<uint8_t> ec_point;
   Botan::DER_Encoder(ec_point).encode(
-      priv_key_sw.public_point().encode(Botan::PointGFp::Compression_Type::UNCOMPRESSED),
+      priv_key_sw.public_point().encode(Botan::EC_Point::Compression_Type::UNCOMPRESSED),
       Botan::ASN1_Type::OctetString);
   Botan::PKCS11::EC_PublicKeyImportProperties pub_import_props(priv_key_sw.DER_domain(), ec_point);
 
@@ -107,10 +107,10 @@ int main() {
   Botan::PK_Key_Agreement kb(key_pair_other.second, rng, "Raw", "pkcs11");
 
   Botan::SymmetricKey alice_key =
-      ka.derive_key(32, key_pair_other.first.public_point().encode(Botan::PointGFp::UNCOMPRESSED));
+      ka.derive_key(32, key_pair_other.first.public_point().encode(Botan::EC_Point::UNCOMPRESSED));
 
   Botan::SymmetricKey bob_key =
-      kb.derive_key(32, key_pair.first.public_point().encode(Botan::PointGFp::UNCOMPRESSED));
+      kb.derive_key(32, key_pair.first.public_point().encode(Botan::EC_Point::UNCOMPRESSED));
 
   bool eq = alice_key == bob_key;
 
diff --git a/src/examples/pkcs11_ecdsa.cpp b/src/examples/pkcs11_ecdsa.cpp
index c93dd6f9d..45aa92d03 100644
--- a/src/examples/pkcs11_ecdsa.cpp
+++ b/src/examples/pkcs11_ecdsa.cpp
@@ -54,7 +54,7 @@ int main() {
   // import to card
   std::vector<uint8_t> ec_point;
   Botan::DER_Encoder(ec_point).encode(
-      priv_key_sw.public_point().encode(Botan::PointGFp::Compression_Type::UNCOMPRESSED),
+      priv_key_sw.public_point().encode(Botan::EC_Point::Compression_Type::UNCOMPRESSED),
       Botan::ASN1_Type::OctetString);
   Botan::PKCS11::EC_PublicKeyImportProperties pub_import_props(priv_key_sw.DER_domain(), ec_point);
 
diff --git a/src/fuzzer/ecc_helper.h b/src/fuzzer/ecc_helper.h
index 9d9f881b1..9623ddf92 100644
--- a/src/fuzzer/ecc_helper.h
+++ b/src/fuzzer/ecc_helper.h
@@ -14,7 +14,7 @@
 
 namespace {
 
-inline std::ostream& operator<<(std::ostream& o, const Botan::PointGFp& point)
+inline std::ostream& operator<<(std::ostream& o, const Botan::EC_Point& point)
    {
    o << point.get_affine_x() << "," << point.get_affine_y();
    return o;
@@ -48,40 +48,40 @@ void check_ecc_math(const Botan::EC_Group& group,
                     const uint8_t in[], size_t len)
    {
    // These depend only on the group, which is also static
-   static const Botan::PointGFp base_point = group.get_base_point();
+   static const Botan::EC_Point base_point = group.get_base_point();
 
    // This is shared across runs to reduce overhead
-   static std::vector<Botan::BigInt> ws(Botan::PointGFp::WORKSPACE_SIZE);
+   static std::vector<Botan::BigInt> ws(Botan::EC_Point::WORKSPACE_SIZE);
 
    const size_t hlen = len / 2;
    const Botan::BigInt a = Botan::BigInt::decode(in, hlen);
    const Botan::BigInt b = Botan::BigInt::decode(in + hlen, len - hlen);
    const Botan::BigInt c = a + b;
 
-   const Botan::PointGFp P1 = base_point * a;
-   const Botan::PointGFp Q1 = base_point * b;
-   const Botan::PointGFp R1 = base_point * c;
+   const Botan::EC_Point P1 = base_point * a;
+   const Botan::EC_Point Q1 = base_point * b;
+   const Botan::EC_Point R1 = base_point * c;
 
-   const Botan::PointGFp S1 = P1 + Q1;
-   const Botan::PointGFp T1 = Q1 + P1;
+   const Botan::EC_Point S1 = P1 + Q1;
+   const Botan::EC_Point T1 = Q1 + P1;
 
    FUZZER_ASSERT_EQUAL(S1, R1);
    FUZZER_ASSERT_EQUAL(T1, R1);
 
-   const Botan::PointGFp P2 = group.blinded_base_point_multiply(a, fuzzer_rng(), ws);
-   const Botan::PointGFp Q2 = group.blinded_base_point_multiply(b, fuzzer_rng(), ws);
-   const Botan::PointGFp R2 = group.blinded_base_point_multiply(c, fuzzer_rng(), ws);
-   const Botan::PointGFp S2 = P2 + Q2;
-   const Botan::PointGFp T2 = Q2 + P2;
+   const Botan::EC_Point P2 = group.blinded_base_point_multiply(a, fuzzer_rng(), ws);
+   const Botan::EC_Point Q2 = group.blinded_base_point_multiply(b, fuzzer_rng(), ws);
+   const Botan::EC_Point R2 = group.blinded_base_point_multiply(c, fuzzer_rng(), ws);
+   const Botan::EC_Point S2 = P2 + Q2;
+   const Botan::EC_Point T2 = Q2 + P2;
 
    FUZZER_ASSERT_EQUAL(S2, R2);
    FUZZER_ASSERT_EQUAL(T2, R2);
 
-   const Botan::PointGFp P3 = group.blinded_var_point_multiply(base_point, a, fuzzer_rng(), ws);
-   const Botan::PointGFp Q3 = group.blinded_var_point_multiply(base_point, b, fuzzer_rng(), ws);
-   const Botan::PointGFp R3 = group.blinded_var_point_multiply(base_point, c, fuzzer_rng(), ws);
-   const Botan::PointGFp S3 = P3 + Q3;
-   const Botan::PointGFp T3 = Q3 + P3;
+   const Botan::EC_Point P3 = group.blinded_var_point_multiply(base_point, a, fuzzer_rng(), ws);
+   const Botan::EC_Point Q3 = group.blinded_var_point_multiply(base_point, b, fuzzer_rng(), ws);
+   const Botan::EC_Point R3 = group.blinded_var_point_multiply(base_point, c, fuzzer_rng(), ws);
+   const Botan::EC_Point S3 = P3 + Q3;
+   const Botan::EC_Point T3 = Q3 + P3;
 
    FUZZER_ASSERT_EQUAL(S3, R3);
    FUZZER_ASSERT_EQUAL(T3, R3);
diff --git a/src/fuzzer/os2ecp.cpp b/src/fuzzer/os2ecp.cpp
index cb4a50b47..029ba4f6f 100644
--- a/src/fuzzer/os2ecp.cpp
+++ b/src/fuzzer/os2ecp.cpp
@@ -5,7 +5,7 @@
 */
 #include "fuzzers.h"
 #include <botan/ec_group.h>
-#include <botan/point_gfp.h>
+#include <botan/ec_point.h>
 
 namespace {
 
@@ -13,7 +13,7 @@ void check_os2ecp(const Botan::EC_Group& group, const uint8_t in[], size_t len)
    {
    try
       {
-      Botan::PointGFp point = group.OS2ECP(in, len);
+      Botan::EC_Point point = group.OS2ECP(in, len);
       }
    catch(Botan::Exception& e) {}
    }
diff --git a/src/lib/ffi/ffi_pkey_algs.cpp b/src/lib/ffi/ffi_pkey_algs.cpp
index 3fd773168..b8e3662f2 100644
--- a/src/lib/ffi/ffi_pkey_algs.cpp
+++ b/src/lib/ffi/ffi_pkey_algs.cpp
@@ -93,7 +93,7 @@ int pubkey_load_ec(std::unique_ptr<ECPublicKey_t>& key,
       return BOTAN_FFI_ERROR_NULL_POINTER;
 
    Botan::EC_Group grp(curve_name);
-   Botan::PointGFp uncompressed_point = grp.point(public_x, public_y);
+   Botan::EC_Point uncompressed_point = grp.point(public_x, public_y);
    key.reset(new ECPublicKey_t(grp, uncompressed_point));
    return BOTAN_FFI_SUCCESS;
    }
diff --git a/src/lib/prov/pkcs11/p11_ecc_key.cpp b/src/lib/prov/pkcs11/p11_ecc_key.cpp
index 8561a1361..f60e2f4d7 100644
--- a/src/lib/prov/pkcs11/p11_ecc_key.cpp
+++ b/src/lib/prov/pkcs11/p11_ecc_key.cpp
@@ -16,8 +16,8 @@
 
 namespace Botan::PKCS11 {
 namespace {
-/// Converts a DER-encoded ANSI X9.62 ECPoint to PointGFp
-PointGFp decode_public_point(const secure_vector<uint8_t>& ec_point_data, const EC_Group& group)
+/// Converts a DER-encoded ANSI X9.62 ECPoint to EC_Point
+EC_Point decode_public_point(const secure_vector<uint8_t>& ec_point_data, const EC_Group& group)
    {
    secure_vector<uint8_t> ec_point;
    BER_Decoder(ec_point_data).decode(ec_point, ASN1_Type::OctetString);
@@ -111,7 +111,7 @@ size_t PKCS11_EC_PrivateKey::key_length() const
 
 std::vector<uint8_t> PKCS11_EC_PrivateKey::public_key_bits() const
    {
-   return public_point().encode(PointGFp::COMPRESSED);
+   return public_point().encode(EC_Point::COMPRESSED);
    }
 
 size_t PKCS11_EC_PrivateKey::estimated_strength() const
diff --git a/src/lib/prov/pkcs11/p11_ecc_key.h b/src/lib/prov/pkcs11/p11_ecc_key.h
index 46e24439d..da39a6c5a 100644
--- a/src/lib/prov/pkcs11/p11_ecc_key.h
+++ b/src/lib/prov/pkcs11/p11_ecc_key.h
@@ -169,7 +169,7 @@ class BOTAN_PUBLIC_API(2,0) PKCS11_EC_PrivateKey : public virtual Private_Key,
       * @param point the public point
       * @param point_encoding encoding of the point (default DER-encoded)
       */
-      void set_public_point(const PointGFp& point, PublicPointEncoding point_encoding = PublicPointEncoding::Der)
+      void set_public_point(const EC_Point& point, PublicPointEncoding point_encoding = PublicPointEncoding::Der)
          {
          m_public_key = point;
          m_point_encoding = point_encoding;
@@ -192,7 +192,7 @@ class BOTAN_PUBLIC_API(2,0) PKCS11_EC_PrivateKey : public virtual Private_Key,
       * @return the public point of the private key
       * @throws Exception if the public point was not set using set_public_point()
       */
-      const PointGFp& public_point() const
+      const EC_Point& public_point() const
          {
          if(m_public_key.is_zero())
             {
@@ -221,7 +221,7 @@ class BOTAN_PUBLIC_API(2,0) PKCS11_EC_PrivateKey : public virtual Private_Key,
 
    private:
       EC_Group m_domain_params;
-      PointGFp m_public_key;
+      EC_Point m_public_key;
       PublicPointEncoding m_point_encoding = PublicPointEncoding::Der;
    };
 }
diff --git a/src/lib/prov/pkcs11/p11_ecdh.h b/src/lib/prov/pkcs11/p11_ecdh.h
index aa2975a42..4ad08c773 100644
--- a/src/lib/prov/pkcs11/p11_ecdh.h
+++ b/src/lib/prov/pkcs11/p11_ecdh.h
@@ -97,7 +97,7 @@ class BOTAN_PUBLIC_API(2,0) PKCS11_ECDH_PrivateKey final : public virtual PKCS11
 
       inline std::vector<uint8_t> public_value() const override
          {
-         return public_point().encode(PointGFp::UNCOMPRESSED);
+         return public_point().encode(EC_Point::UNCOMPRESSED);
          }
 
       /// @return the exported ECDH private key
diff --git a/src/lib/pubkey/ec_group/curve_gfp.h b/src/lib/pubkey/ec_group/curve_gfp.h
index 77c04ebf3..fdc483d7e 100644
--- a/src/lib/pubkey/ec_group/curve_gfp.h
+++ b/src/lib/pubkey/ec_group/curve_gfp.h
@@ -13,7 +13,7 @@
 #include <botan/bigint.h>
 #include <memory>
 
-// Currently exposed in PointGFp
+// Currently exposed in EC_Point
 //BOTAN_FUTURE_INTERNAL_HEADER(curve_gfp.h)
 
 namespace Botan {
@@ -88,7 +88,7 @@ class BOTAN_UNSTABLE_API CurveGFp_Repr
 * This class represents an elliptic curve over GF(p)
 *
 * There should not be any reason for applications to use this type.
-* If you need EC primitives use the interfaces EC_Group and PointGFp
+* If you need EC primitives use the interfaces EC_Group and EC_Point
 *
 * It is likely this class will be removed entirely in a future major
 * release.
diff --git a/src/lib/pubkey/ec_group/ec_group.cpp b/src/lib/pubkey/ec_group/ec_group.cpp
index 2e94ec5fc..13ccbc51e 100644
--- a/src/lib/pubkey/ec_group/ec_group.cpp
+++ b/src/lib/pubkey/ec_group/ec_group.cpp
@@ -97,7 +97,7 @@ class EC_Group_Data final
       size_t order_bytes() const { return (m_order_bits + 7) / 8; }
 
       const CurveGFp& curve() const { return m_curve; }
-      const PointGFp& base_point() const { return m_base_point; }
+      const EC_Point& base_point() const { return m_base_point; }
 
       bool a_is_minus_3() const { return m_a_is_minus_3; }
       bool a_is_zero() const { return m_a_is_zero; }
@@ -124,7 +124,7 @@ class EC_Group_Data final
          return inverse_mod(x, m_order);
          }
 
-      PointGFp blinded_base_point_multiply(const BigInt& k,
+      EC_Point blinded_base_point_multiply(const BigInt& k,
                                            RandomNumberGenerator& rng,
                                            std::vector<BigInt>& ws) const
          {
@@ -135,14 +135,14 @@ class EC_Group_Data final
 
    private:
       CurveGFp m_curve;
-      PointGFp m_base_point;
+      EC_Point m_base_point;
 
       BigInt m_g_x;
       BigInt m_g_y;
       BigInt m_order;
       BigInt m_cofactor;
       Modular_Reducer m_mod_order;
-      PointGFp_Base_Point_Precompute m_base_mult;
+      EC_Point_Base_Point_Precompute m_base_mult;
       OID m_oid;
       size_t m_p_bits;
       size_t m_order_bits;
@@ -541,7 +541,7 @@ const BigInt& EC_Group::get_b() const
    return data().b();
    }
 
-const PointGFp& EC_Group::get_base_point() const
+const EC_Point& EC_Group::get_base_point() const
    {
    return data().base_point();
    }
@@ -601,21 +601,21 @@ EC_Group_Source EC_Group::source() const
    return data().source();
    }
 
-size_t EC_Group::point_size(PointGFp::Compression_Type format) const
+size_t EC_Group::point_size(EC_Point::Compression_Type format) const
    {
    // Hybrid and standard format are (x,y), compressed is y, +1 format byte
-   if(format == PointGFp::COMPRESSED)
+   if(format == EC_Point::COMPRESSED)
       return (1 + get_p_bytes());
    else
       return (1 + 2*get_p_bytes());
    }
 
-PointGFp EC_Group::OS2ECP(const uint8_t bits[], size_t len) const
+EC_Point EC_Group::OS2ECP(const uint8_t bits[], size_t len) const
    {
    return Botan::OS2ECP(bits, len, data().curve());
    }
 
-PointGFp EC_Group::point(const BigInt& x, const BigInt& y) const
+EC_Point EC_Group::point(const BigInt& x, const BigInt& y) const
    {
    #if 0
    BigInt l = (x*x*x + x*get_a() + get_b()) % get_p();
@@ -627,16 +627,16 @@ PointGFp EC_Group::point(const BigInt& x, const BigInt& y) const
       }
 #endif
    // TODO: randomize the representation?
-   return PointGFp(data().curve(), x, y);
+   return EC_Point(data().curve(), x, y);
    }
 
-PointGFp EC_Group::point_multiply(const BigInt& x, const PointGFp& pt, const BigInt& y) const
+EC_Point EC_Group::point_multiply(const BigInt& x, const EC_Point& pt, const BigInt& y) const
    {
-   PointGFp_Multi_Point_Precompute xy_mul(get_base_point(), pt);
+   EC_Point_Multi_Point_Precompute xy_mul(get_base_point(), pt);
    return xy_mul.multi_exp(x, y);
    }
 
-PointGFp EC_Group::blinded_base_point_multiply(const BigInt& k,
+EC_Point EC_Group::blinded_base_point_multiply(const BigInt& k,
                                                RandomNumberGenerator& rng,
                                                std::vector<BigInt>& ws) const
    {
@@ -647,7 +647,7 @@ BigInt EC_Group::blinded_base_point_multiply_x(const BigInt& k,
                                                RandomNumberGenerator& rng,
                                                std::vector<BigInt>& ws) const
    {
-   const PointGFp pt = data().blinded_base_point_multiply(k, rng, ws);
+   const EC_Point pt = data().blinded_base_point_multiply(k, rng, ws);
 
    if(pt.is_zero())
       return BigInt::zero();
@@ -659,21 +659,21 @@ BigInt EC_Group::random_scalar(RandomNumberGenerator& rng) const
    return BigInt::random_integer(rng, BigInt::one(), get_order());
    }
 
-PointGFp EC_Group::blinded_var_point_multiply(const PointGFp& point,
+EC_Point EC_Group::blinded_var_point_multiply(const EC_Point& point,
                                               const BigInt& k,
                                               RandomNumberGenerator& rng,
                                               std::vector<BigInt>& ws) const
    {
-   PointGFp_Var_Point_Precompute mul(point, rng, ws);
+   EC_Point_Var_Point_Precompute mul(point, rng, ws);
    return mul.mul(k, rng, get_order(), ws);
    }
 
-PointGFp EC_Group::zero_point() const
+EC_Point EC_Group::zero_point() const
    {
-   return PointGFp(data().curve());
+   return EC_Point(data().curve());
    }
 
-PointGFp EC_Group::hash_to_curve(const std::string& hash_fn,
+EC_Point EC_Group::hash_to_curve(const std::string& hash_fn,
                                  const uint8_t input[],
                                  size_t input_len,
                                  const std::string& domain,
@@ -687,7 +687,7 @@ PointGFp EC_Group::hash_to_curve(const std::string& hash_fn,
                               random_oracle);
    }
 
-PointGFp EC_Group::hash_to_curve(const std::string& hash_fn,
+EC_Point EC_Group::hash_to_curve(const std::string& hash_fn,
                                  const uint8_t input[],
                                  size_t input_len,
                                  const uint8_t domain_sep[],
@@ -739,7 +739,7 @@ EC_Group::DER_encode(EC_Group_Encoding form) const
                .encode(BigInt::encode_1363(get_b(), p_bytes),
                        ASN1_Type::OctetString)
             .end_cons()
-              .encode(get_base_point().encode(PointGFp::UNCOMPRESSED), ASN1_Type::OctetString)
+              .encode(get_base_point().encode(EC_Point::UNCOMPRESSED), ASN1_Type::OctetString)
             .encode(get_order())
             .encode(get_cofactor())
          .end_cons();
@@ -785,7 +785,7 @@ bool EC_Group::operator==(const EC_Group& other) const
            get_cofactor() == other.get_cofactor());
    }
 
-bool EC_Group::verify_public_element(const PointGFp& point) const
+bool EC_Group::verify_public_element(const EC_Point& point) const
    {
    //check that public point is not at infinity
    if(point.is_zero())
@@ -820,7 +820,7 @@ bool EC_Group::verify_group(RandomNumberGenerator& rng,
    const BigInt& a = get_a();
    const BigInt& b = get_b();
    const BigInt& order = get_order();
-   const PointGFp& base_point = get_base_point();
+   const EC_Point& base_point = get_base_point();
 
    if(p <= 3 || order <= 0)
       return false;
diff --git a/src/lib/pubkey/ec_group/ec_group.h b/src/lib/pubkey/ec_group/ec_group.h
index 6ae180ee9..d727b17e6 100644
--- a/src/lib/pubkey/ec_group/ec_group.h
+++ b/src/lib/pubkey/ec_group/ec_group.h
@@ -10,7 +10,7 @@
 #ifndef BOTAN_ECC_DOMAIN_PARAMETERS_H_
 #define BOTAN_ECC_DOMAIN_PARAMETERS_H_
 
-#include <botan/point_gfp.h>
+#include <botan/ec_point.h>
 #include <botan/asn1_obj.h>
 #include <memory>
 #include <set>
@@ -174,7 +174,7 @@ class BOTAN_PUBLIC_API(2,0) EC_Group final
       * Return group base point
       * @result base point
       */
-      const PointGFp& get_base_point() const;
+      const EC_Point& get_base_point() const;
 
       /**
       * Return the x coordinate of the base point
@@ -237,7 +237,7 @@ class BOTAN_PUBLIC_API(2,0) EC_Group final
       * In particular, checks that it is a point on the curve, not infinity,
       * and that it has order matching the group.
       */
-      bool verify_public_element(const PointGFp& y) const;
+      bool verify_public_element(const EC_Point& y) const;
 
       /**
       * Return the OID of these domain parameters
@@ -248,13 +248,13 @@ class BOTAN_PUBLIC_API(2,0) EC_Group final
       /**
       * Return a point on this curve with the affine values x, y
       */
-      PointGFp point(const BigInt& x, const BigInt& y) const;
+      EC_Point point(const BigInt& x, const BigInt& y) const;
 
       /**
       * Multi exponentiate. Not constant time.
       * @return base_point*x + pt*y
       */
-      PointGFp point_multiply(const BigInt& x, const PointGFp& pt, const BigInt& y) const;
+      EC_Point point_multiply(const BigInt& x, const EC_Point& pt, const BigInt& y) const;
 
       /**
       * Blinded point multiplication, attempts resistance to side channels
@@ -263,7 +263,7 @@ class BOTAN_PUBLIC_API(2,0) EC_Group final
       * @param ws a temp workspace
       * @return base_point*k
       */
-      PointGFp blinded_base_point_multiply(const BigInt& k,
+      EC_Point blinded_base_point_multiply(const BigInt& k,
                                            RandomNumberGenerator& rng,
                                            std::vector<BigInt>& ws) const;
 
@@ -288,7 +288,7 @@ class BOTAN_PUBLIC_API(2,0) EC_Group final
       * @param ws a temp workspace
       * @return point*k
       */
-      PointGFp blinded_var_point_multiply(const PointGFp& point,
+      EC_Point blinded_var_point_multiply(const EC_Point& point,
                                           const BigInt& k,
                                           RandomNumberGenerator& rng,
                                           std::vector<BigInt>& ws) const;
@@ -311,7 +311,7 @@ class BOTAN_PUBLIC_API(2,0) EC_Group final
       * @param random_oracle if the mapped point must be uniform (use
                "true" here unless you know what you are doing)
       */
-      PointGFp hash_to_curve(const std::string& hash_fn,
+      EC_Point hash_to_curve(const std::string& hash_fn,
                              const uint8_t input[],
                              size_t input_len,
                              const uint8_t domain_sep[],
@@ -330,7 +330,7 @@ class BOTAN_PUBLIC_API(2,0) EC_Group final
       * @param random_oracle if the mapped point must be uniform (use
                "true" here unless you know what you are doing)
       */
-      PointGFp hash_to_curve(const std::string& hash_fn,
+      EC_Point hash_to_curve(const std::string& hash_fn,
                              const uint8_t input[],
                              size_t input_len,
                              const std::string& domain_sep,
@@ -339,14 +339,14 @@ class BOTAN_PUBLIC_API(2,0) EC_Group final
       /**
       * Return the zero (or infinite) point on this curve
       */
-      PointGFp zero_point() const;
+      EC_Point zero_point() const;
 
-      size_t point_size(PointGFp::Compression_Type format) const;
+      size_t point_size(EC_Point::Compression_Type format) const;
 
-      PointGFp OS2ECP(const uint8_t bits[], size_t len) const;
+      EC_Point OS2ECP(const uint8_t bits[], size_t len) const;
 
       template<typename Alloc>
-      PointGFp OS2ECP(const std::vector<uint8_t, Alloc>& vec) const
+      EC_Point OS2ECP(const std::vector<uint8_t, Alloc>& vec) const
          {
          return this->OS2ECP(vec.data(), vec.size());
          }
diff --git a/src/lib/pubkey/ec_group/point_gfp.cpp b/src/lib/pubkey/ec_group/ec_point.cpp
similarity index 89%
rename from src/lib/pubkey/ec_group/point_gfp.cpp
rename to src/lib/pubkey/ec_group/ec_point.cpp
index 168cede64..7583b461f 100644
--- a/src/lib/pubkey/ec_group/point_gfp.cpp
+++ b/src/lib/pubkey/ec_group/ec_point.cpp
@@ -7,14 +7,14 @@
 * Botan is released under the Simplified BSD License (see license.txt)
 */
 
-#include <botan/point_gfp.h>
+#include <botan/ec_point.h>
 #include <botan/numthry.h>
 #include <botan/rng.h>
 #include <botan/internal/ct_utils.h>
 
 namespace Botan {
 
-PointGFp::PointGFp(const CurveGFp& curve) :
+EC_Point::EC_Point(const CurveGFp& curve) :
    m_curve(curve),
    m_coord_x(0),
    m_coord_y(curve.get_1_rep()),
@@ -23,29 +23,29 @@ PointGFp::PointGFp(const CurveGFp& curve) :
    // Assumes Montgomery rep of zero is zero
    }
 
-PointGFp::PointGFp(const CurveGFp& curve, const BigInt& x, const BigInt& y) :
+EC_Point::EC_Point(const CurveGFp& curve, const BigInt& x, const BigInt& y) :
    m_curve(curve),
    m_coord_x(x),
    m_coord_y(y),
    m_coord_z(m_curve.get_1_rep())
    {
    if(x < 0 || x >= curve.get_p())
-      throw Invalid_Argument("Invalid PointGFp affine x");
+      throw Invalid_Argument("Invalid EC_Point affine x");
    if(y < 0 || y >= curve.get_p())
-      throw Invalid_Argument("Invalid PointGFp affine y");
+      throw Invalid_Argument("Invalid EC_Point affine y");
 
    secure_vector<word> monty_ws(m_curve.get_ws_size());
    m_curve.to_rep(m_coord_x, monty_ws);
    m_curve.to_rep(m_coord_y, monty_ws);
    }
 
-void PointGFp::randomize_repr(RandomNumberGenerator& rng)
+void EC_Point::randomize_repr(RandomNumberGenerator& rng)
    {
    secure_vector<word> ws(m_curve.get_ws_size());
    randomize_repr(rng, ws);
    }
 
-void PointGFp::randomize_repr(RandomNumberGenerator& rng, secure_vector<word>& ws)
+void EC_Point::randomize_repr(RandomNumberGenerator& rng, secure_vector<word>& ws)
    {
    const BigInt mask = BigInt::random_integer(rng, 2, m_curve.get_p());
 
@@ -68,8 +68,8 @@ namespace {
 
 inline void resize_ws(std::vector<BigInt>& ws_bn, size_t cap_size)
    {
-   BOTAN_ASSERT(ws_bn.size() >= PointGFp::WORKSPACE_SIZE,
-                "Expected size for PointGFp workspace");
+   BOTAN_ASSERT(ws_bn.size() >= EC_Point::WORKSPACE_SIZE,
+                "Expected size for EC_Point workspace");
 
    for(auto& ws : ws_bn)
       if(ws.size() < cap_size)
@@ -86,7 +86,7 @@ inline word all_zeros(const word x[], size_t len)
 
 }
 
-void PointGFp::add_affine(const word x_words[], size_t x_size,
+void EC_Point::add_affine(const word x_words[], size_t x_size,
                           const word y_words[], size_t y_size,
                           std::vector<BigInt>& ws_bn)
    {
@@ -169,7 +169,7 @@ void PointGFp::add_affine(const word x_words[], size_t x_size,
    m_coord_z.swap(T0);
    }
 
-void PointGFp::add(const word x_words[], size_t x_size,
+void EC_Point::add(const word x_words[], size_t x_size,
                    const word y_words[], size_t y_size,
                    const word z_words[], size_t z_size,
                    std::vector<BigInt>& ws_bn)
@@ -255,14 +255,14 @@ void PointGFp::add(const word x_words[], size_t x_size,
    m_curve.mul(m_coord_z, T3, T4, ws);
    }
 
-void PointGFp::mult2i(size_t iterations, std::vector<BigInt>& ws_bn)
+void EC_Point::mult2i(size_t iterations, std::vector<BigInt>& ws_bn)
    {
    if(iterations == 0)
       return;
 
    if(m_coord_y.is_zero())
       {
-      *this = PointGFp(m_curve); // setting myself to zero
+      *this = EC_Point(m_curve); // setting myself to zero
       return;
       }
 
@@ -275,14 +275,14 @@ void PointGFp::mult2i(size_t iterations, std::vector<BigInt>& ws_bn)
    }
 
 // *this *= 2
-void PointGFp::mult2(std::vector<BigInt>& ws_bn)
+void EC_Point::mult2(std::vector<BigInt>& ws_bn)
    {
    if(is_zero())
       return;
 
    if(m_coord_y.is_zero())
       {
-      *this = PointGFp(m_curve); // setting myself to zero
+      *this = EC_Point(m_curve); // setting myself to zero
       return;
       }
 
@@ -365,16 +365,16 @@ void PointGFp::mult2(std::vector<BigInt>& ws_bn)
    }
 
 // arithmetic operators
-PointGFp& PointGFp::operator+=(const PointGFp& rhs)
+EC_Point& EC_Point::operator+=(const EC_Point& rhs)
    {
-   std::vector<BigInt> ws(PointGFp::WORKSPACE_SIZE);
+   std::vector<BigInt> ws(EC_Point::WORKSPACE_SIZE);
    add(rhs, ws);
    return *this;
    }
 
-PointGFp& PointGFp::operator-=(const PointGFp& rhs)
+EC_Point& EC_Point::operator-=(const EC_Point& rhs)
    {
-   PointGFp minus_rhs = PointGFp(rhs).negate();
+   EC_Point minus_rhs = EC_Point(rhs).negate();
 
    if(is_zero())
       *this = minus_rhs;
@@ -384,21 +384,21 @@ PointGFp& PointGFp::operator-=(const PointGFp& rhs)
    return *this;
    }
 
-PointGFp& PointGFp::operator*=(const BigInt& scalar)
+EC_Point& EC_Point::operator*=(const BigInt& scalar)
    {
    *this = scalar * *this;
    return *this;
    }
 
-PointGFp operator*(const BigInt& scalar, const PointGFp& point)
+EC_Point operator*(const BigInt& scalar, const EC_Point& point)
    {
    BOTAN_DEBUG_ASSERT(point.on_the_curve());
 
    const size_t scalar_bits = scalar.bits();
 
-   std::vector<BigInt> ws(PointGFp::WORKSPACE_SIZE);
+   std::vector<BigInt> ws(EC_Point::WORKSPACE_SIZE);
 
-   PointGFp R[2] = { point.zero(), point };
+   EC_Point R[2] = { point.zero(), point };
 
    for(size_t i = scalar_bits; i > 0; i--)
       {
@@ -416,7 +416,7 @@ PointGFp operator*(const BigInt& scalar, const PointGFp& point)
    }
 
 //static
-void PointGFp::force_all_affine(std::vector<PointGFp>& points,
+void EC_Point::force_all_affine(std::vector<EC_Point>& points,
                                 secure_vector<word>& ws)
    {
    if(points.size() <= 1)
@@ -461,7 +461,7 @@ void PointGFp::force_all_affine(std::vector<PointGFp>& points,
 
    for(size_t i = points.size() - 1; i != 0; i--)
       {
-      PointGFp& point = points[i];
+      EC_Point& point = points[i];
 
       curve.mul(z_inv, s_inv, c[i-1], ws);
 
@@ -481,7 +481,7 @@ void PointGFp::force_all_affine(std::vector<PointGFp>& points,
    points[0].m_coord_z = rep_1;
    }
 
-void PointGFp::force_affine()
+void EC_Point::force_affine()
    {
    if(is_zero())
       throw Invalid_State("Cannot convert zero ECC point to affine");
@@ -496,12 +496,12 @@ void PointGFp::force_affine()
    m_coord_z = m_curve.get_1_rep();
    }
 
-bool PointGFp::is_affine() const
+bool EC_Point::is_affine() const
    {
    return m_curve.is_one(m_coord_z);
    }
 
-BigInt PointGFp::get_affine_x() const
+BigInt EC_Point::get_affine_x() const
    {
    if(is_zero())
       throw Invalid_State("Cannot convert zero point to affine");
@@ -520,7 +520,7 @@ BigInt PointGFp::get_affine_x() const
    return r;
    }
 
-BigInt PointGFp::get_affine_y() const
+BigInt EC_Point::get_affine_y() const
    {
    if(is_zero())
       throw Invalid_State("Cannot convert zero point to affine");
@@ -540,7 +540,7 @@ BigInt PointGFp::get_affine_y() const
    return r;
    }
 
-bool PointGFp::on_the_curve() const
+bool EC_Point::on_the_curve() const
    {
    /*
    Is the point still on the curve?? (If everything is correct, the
@@ -575,7 +575,7 @@ bool PointGFp::on_the_curve() const
    }
 
 // swaps the states of *this and other, does not throw!
-void PointGFp::swap(PointGFp& other)
+void EC_Point::swap(EC_Point& other)
    {
    m_curve.swap(other.m_curve);
    m_coord_x.swap(other.m_coord_x);
@@ -583,7 +583,7 @@ void PointGFp::swap(PointGFp& other)
    m_coord_z.swap(other.m_coord_z);
    }
 
-bool PointGFp::operator==(const PointGFp& other) const
+bool EC_Point::operator==(const EC_Point& other) const
    {
    if(m_curve != other.m_curve)
       return false;
@@ -597,7 +597,7 @@ bool PointGFp::operator==(const PointGFp& other) const
    }
 
 // encoding and decoding
-std::vector<uint8_t> PointGFp::encode(PointGFp::Compression_Type format) const
+std::vector<uint8_t> EC_Point::encode(EC_Point::Compression_Type format) const
    {
    if(is_zero())
       return std::vector<uint8_t>(1); // single 0 byte
@@ -609,20 +609,20 @@ std::vector<uint8_t> PointGFp::encode(PointGFp::Compression_Type format) const
 
    std::vector<uint8_t> result;
 
-   if(format == PointGFp::UNCOMPRESSED)
+   if(format == EC_Point::UNCOMPRESSED)
       {
       result.resize(1 + 2*p_bytes);
       result[0] = 0x04;
       BigInt::encode_1363(&result[1], p_bytes, x);
       BigInt::encode_1363(&result[1+p_bytes], p_bytes, y);
       }
-   else if(format == PointGFp::COMPRESSED)
+   else if(format == EC_Point::COMPRESSED)
       {
       result.resize(1 + p_bytes);
       result[0] = 0x02 | static_cast<uint8_t>(y.get_bit(0));
       BigInt::encode_1363(&result[1], p_bytes, x);
       }
-   else if(format == PointGFp::HYBRID)
+   else if(format == EC_Point::HYBRID)
       {
       result.resize(1 + 2*p_bytes);
       result[0] = 0x06 | static_cast<uint8_t>(y.get_bit(0));
@@ -663,16 +663,16 @@ BigInt decompress_point(bool yMod2,
 
 }
 
-PointGFp OS2ECP(const uint8_t data[], size_t data_len,
+EC_Point OS2ECP(const uint8_t data[], size_t data_len,
                 const CurveGFp& curve)
    {
    // Should we really be doing this?
    if(data_len <= 1)
-      return PointGFp(curve); // return zero
+      return EC_Point(curve); // return zero
 
    std::pair<BigInt, BigInt> xy = OS2ECP(data, data_len, curve.get_p(), curve.get_a(), curve.get_b());
 
-   PointGFp point(curve, xy.first, xy.second);
+   EC_Point point(curve, xy.first, xy.second);
 
    if(!point.on_the_curve())
       throw Decoding_Error("OS2ECP: Decoded point was not on the curve");
diff --git a/src/lib/pubkey/ec_group/point_gfp.h b/src/lib/pubkey/ec_group/ec_point.h
similarity index 78%
rename from src/lib/pubkey/ec_group/point_gfp.h
rename to src/lib/pubkey/ec_group/ec_point.h
index 631d0b612..8c9293227 100644
--- a/src/lib/pubkey/ec_group/point_gfp.h
+++ b/src/lib/pubkey/ec_group/ec_point.h
@@ -7,8 +7,8 @@
 * Botan is released under the Simplified BSD License (see license.txt)
 */
 
-#ifndef BOTAN_POINT_GFP_H_
-#define BOTAN_POINT_GFP_H_
+#ifndef BOTAN_EC_POINT_H_
+#define BOTAN_EC_POINT_H_
 
 #include <botan/curve_gfp.h>
 #include <botan/exceptn.h>
@@ -19,7 +19,7 @@ namespace Botan {
 /**
 * This class represents one point on a curve of GF(p)
 */
-class BOTAN_PUBLIC_API(2,0) PointGFp final
+class BOTAN_PUBLIC_API(2,0) EC_Point final
    {
    public:
       enum Compression_Type {
@@ -31,25 +31,25 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
       enum { WORKSPACE_SIZE = 8 };
 
       /**
-      * Construct an uninitialized PointGFp
+      * Construct an uninitialized EC_Point
       */
-      PointGFp() = default;
+      EC_Point() = default;
 
       /**
       * Construct the zero point
       * @param curve The base curve
       */
-      explicit PointGFp(const CurveGFp& curve);
+      explicit EC_Point(const CurveGFp& curve);
 
       /**
       * Copy constructor
       */
-      PointGFp(const PointGFp&) = default;
+      EC_Point(const EC_Point&) = default;
 
       /**
       * Move Constructor
       */
-      PointGFp(PointGFp&& other)
+      EC_Point(EC_Point&& other)
          {
          this->swap(other);
          }
@@ -57,12 +57,12 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
       /**
       * Standard Assignment
       */
-      PointGFp& operator=(const PointGFp&) = default;
+      EC_Point& operator=(const EC_Point&) = default;
 
       /**
       * Move Assignment
       */
-      PointGFp& operator=(PointGFp&& other)
+      EC_Point& operator=(EC_Point&& other)
          {
          if(this != &other)
             this->swap(other);
@@ -76,40 +76,40 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
       * @param x affine x coordinate
       * @param y affine y coordinate
       */
-      PointGFp(const CurveGFp& curve, const BigInt& x, const BigInt& y);
+      EC_Point(const CurveGFp& curve, const BigInt& x, const BigInt& y);
 
       /**
       * EC2OSP - elliptic curve to octet string primitive
       * @param format which format to encode using
       */
-      std::vector<uint8_t> encode(PointGFp::Compression_Type format) const;
+      std::vector<uint8_t> encode(EC_Point::Compression_Type format) const;
 
       /**
       * += Operator
-      * @param rhs the PointGFp to add to the local value
-      * @result resulting PointGFp
+      * @param rhs the EC_Point to add to the local value
+      * @result resulting EC_Point
       */
-      PointGFp& operator+=(const PointGFp& rhs);
+      EC_Point& operator+=(const EC_Point& rhs);
 
       /**
       * -= Operator
-      * @param rhs the PointGFp to subtract from the local value
-      * @result resulting PointGFp
+      * @param rhs the EC_Point to subtract from the local value
+      * @result resulting EC_Point
       */
-      PointGFp& operator-=(const PointGFp& rhs);
+      EC_Point& operator-=(const EC_Point& rhs);
 
       /**
       * *= Operator
-      * @param scalar the PointGFp to multiply with *this
-      * @result resulting PointGFp
+      * @param scalar the EC_Point to multiply with *this
+      * @result resulting EC_Point
       */
-      PointGFp& operator*=(const BigInt& scalar);
+      EC_Point& operator*=(const BigInt& scalar);
 
       /**
       * Negate this point
       * @return *this
       */
-      PointGFp& negate()
+      EC_Point& negate()
          {
          if(!is_zero())
             m_coord_y = m_curve.get_p() - m_coord_y;
@@ -147,7 +147,7 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
       /**
       * Force all points on the list to affine coordinates
       */
-      static void force_all_affine(std::vector<PointGFp>& points,
+      static void force_all_affine(std::vector<EC_Point>& points,
                                    secure_vector<word>& ws);
 
       bool is_affine() const;
@@ -169,7 +169,7 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
       * swaps the states of *this and other, does not throw!
       * @param other the object to swap values with
       */
-      void swap(PointGFp& other);
+      void swap(EC_Point& other);
 
       /**
       * Randomize the point representation
@@ -186,14 +186,14 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
       /**
       * Equality operator
       */
-      bool operator==(const PointGFp& other) const;
+      bool operator==(const EC_Point& other) const;
 
       /**
       * Point addition
       * @param other the point to add to *this
       * @param workspace temp space, at least WORKSPACE_SIZE elements
       */
-      void add(const PointGFp& other, std::vector<BigInt>& workspace)
+      void add(const EC_Point& other, std::vector<BigInt>& workspace)
          {
          BOTAN_ARG_CHECK(m_curve == other.m_curve, "cannot add points on different curves");
 
@@ -226,7 +226,7 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
       * @param other affine point to add - assumed to be affine!
       * @param workspace temp space, at least WORKSPACE_SIZE elements
       */
-      void add_affine(const PointGFp& other, std::vector<BigInt>& workspace)
+      void add_affine(const EC_Point& other, std::vector<BigInt>& workspace)
          {
          BOTAN_ASSERT_NOMSG(m_curve == other.m_curve);
          BOTAN_DEBUG_ASSERT(other.is_affine());
@@ -269,9 +269,9 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
       * @param workspace temp space, at least WORKSPACE_SIZE elements
       * @return other plus *this
       */
-      PointGFp plus(const PointGFp& other, std::vector<BigInt>& workspace) const
+      EC_Point plus(const EC_Point& other, std::vector<BigInt>& workspace) const
          {
-         PointGFp x = (*this);
+         EC_Point x = (*this);
          x.add(other, workspace);
          return x;
          }
@@ -281,9 +281,9 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
       * @param workspace temp space, at least WORKSPACE_SIZE elements
       * @return *this doubled
       */
-      PointGFp double_of(std::vector<BigInt>& workspace) const
+      EC_Point double_of(std::vector<BigInt>& workspace) const
          {
-         PointGFp x = (*this);
+         EC_Point x = (*this);
          x.mult2(workspace);
          return x;
          }
@@ -291,7 +291,7 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
       /**
       * Return the zero (aka infinite) point associated with this curve
       */
-      PointGFp zero() const { return PointGFp(m_curve); }
+      EC_Point zero() const { return EC_Point(m_curve); }
 
       /**
       * Return base curve of this point
@@ -312,7 +312,7 @@ class BOTAN_PUBLIC_API(2,0) PointGFp final
 * @param point the point value
 * @return scalar*point on the curve
 */
-BOTAN_PUBLIC_API(2,0) PointGFp operator*(const BigInt& scalar, const PointGFp& point);
+BOTAN_PUBLIC_API(2,0) EC_Point operator*(const BigInt& scalar, const EC_Point& point);
 
 /**
 * ECC point multiexponentiation - not constant time!
@@ -322,35 +322,35 @@ BOTAN_PUBLIC_API(2,0) PointGFp operator*(const BigInt& scalar, const PointGFp& p
 * @param z2 a scalar
 * @result (p1 * z1 + p2 * z2)
 */
-BOTAN_PUBLIC_API(2,0) PointGFp multi_exponentiate(
-   const PointGFp& p1, const BigInt& z1,
-   const PointGFp& p2, const BigInt& z2);
+BOTAN_PUBLIC_API(2,0) EC_Point multi_exponentiate(
+   const EC_Point& p1, const BigInt& z1,
+   const EC_Point& p2, const BigInt& z2);
 
 // relational operators
-inline bool operator!=(const PointGFp& lhs, const PointGFp& rhs)
+inline bool operator!=(const EC_Point& lhs, const EC_Point& rhs)
    {
    return !(rhs == lhs);
    }
 
 // arithmetic operators
-inline PointGFp operator-(const PointGFp& lhs)
+inline EC_Point operator-(const EC_Point& lhs)
    {
-   return PointGFp(lhs).negate();
+   return EC_Point(lhs).negate();
    }
 
-inline PointGFp operator+(const PointGFp& lhs, const PointGFp& rhs)
+inline EC_Point operator+(const EC_Point& lhs, const EC_Point& rhs)
    {
-   PointGFp tmp(lhs);
+   EC_Point tmp(lhs);
    return tmp += rhs;
    }
 
-inline PointGFp operator-(const PointGFp& lhs, const PointGFp& rhs)
+inline EC_Point operator-(const EC_Point& lhs, const EC_Point& rhs)
    {
-   PointGFp tmp(lhs);
+   EC_Point tmp(lhs);
    return tmp -= rhs;
    }
 
-inline PointGFp operator*(const PointGFp& point, const BigInt& scalar)
+inline EC_Point operator*(const EC_Point& point, const BigInt& scalar)
    {
    return scalar * point;
    }
@@ -359,7 +359,7 @@ inline PointGFp operator*(const PointGFp& point, const BigInt& scalar)
 * Perform point decoding
 * Use EC_Group::OS2ECP instead
 */
-PointGFp BOTAN_PUBLIC_API(2,0) OS2ECP(const uint8_t data[], size_t data_len,
+EC_Point BOTAN_PUBLIC_API(2,0) OS2ECP(const uint8_t data[], size_t data_len,
                                       const CurveGFp& curve);
 
 /**
@@ -378,17 +378,20 @@ std::pair<BigInt, BigInt> BOTAN_UNSTABLE_API OS2ECP(const uint8_t data[], size_t
                                                     const BigInt& curve_b);
 
 template<typename Alloc>
-PointGFp OS2ECP(const std::vector<uint8_t, Alloc>& data, const CurveGFp& curve)
+EC_Point OS2ECP(const std::vector<uint8_t, Alloc>& data, const CurveGFp& curve)
    { return OS2ECP(data.data(), data.size(), curve); }
 
-class PointGFp_Var_Point_Precompute;
+class EC_Point_Var_Point_Precompute;
+
+// The name used for this type in older versions
+typedef EC_Point PointGFp;
 
 }
 
 namespace std {
 
 template<>
-inline void swap<Botan::PointGFp>(Botan::PointGFp& x, Botan::PointGFp& y)
+inline void swap<Botan::EC_Point>(Botan::EC_Point& x, Botan::EC_Point& y)
    { x.swap(y); }
 
 }
diff --git a/src/lib/pubkey/ec_group/info.txt b/src/lib/pubkey/ec_group/info.txt
index 26bc5cafd..8e7175a5f 100644
--- a/src/lib/pubkey/ec_group/info.txt
+++ b/src/lib/pubkey/ec_group/info.txt
@@ -21,5 +21,5 @@ point_mul.h
 <header:public>
 curve_gfp.h
 ec_group.h
-point_gfp.h
+ec_point.h
 </header:public>
diff --git a/src/lib/pubkey/ec_group/point_mul.cpp b/src/lib/pubkey/ec_group/point_mul.cpp
index 8d4441983..9848b6831 100644
--- a/src/lib/pubkey/ec_group/point_mul.cpp
+++ b/src/lib/pubkey/ec_group/point_mul.cpp
@@ -21,20 +21,20 @@ size_t blinding_size(const BigInt& group_order)
 
 }
 
-PointGFp multi_exponentiate(const PointGFp& x, const BigInt& z1,
-                            const PointGFp& y, const BigInt& z2)
+EC_Point multi_exponentiate(const EC_Point& x, const BigInt& z1,
+                            const EC_Point& y, const BigInt& z2)
    {
-   PointGFp_Multi_Point_Precompute xy_mul(x, y);
+   EC_Point_Multi_Point_Precompute xy_mul(x, y);
    return xy_mul.multi_exp(z1, z2);
    }
 
-PointGFp_Base_Point_Precompute::PointGFp_Base_Point_Precompute(const PointGFp& base,
+EC_Point_Base_Point_Precompute::EC_Point_Base_Point_Precompute(const EC_Point& base,
                                                                const Modular_Reducer& mod_order) :
    m_base_point(base),
    m_mod_order(mod_order),
    m_p_words(base.get_curve().get_p().sig_words())
    {
-   std::vector<BigInt> ws(PointGFp::WORKSPACE_SIZE);
+   std::vector<BigInt> ws(EC_Point::WORKSPACE_SIZE);
 
    const size_t p_bits = base.get_curve().get_p().bits();
 
@@ -45,10 +45,10 @@ PointGFp_Base_Point_Precompute::PointGFp_Base_Point_Precompute(const PointGFp& b
    */
    const size_t T_bits = round_up(p_bits + blinding_size(mod_order.get_modulus()) + 1, WINDOW_BITS) / WINDOW_BITS;
 
-   std::vector<PointGFp> T(WINDOW_SIZE*T_bits);
+   std::vector<EC_Point> T(WINDOW_SIZE*T_bits);
 
-   PointGFp g = base;
-   PointGFp g2, g4;
+   EC_Point g = base;
+   EC_Point g2, g4;
 
    for(size_t i = 0; i != T_bits; i++)
       {
@@ -69,7 +69,7 @@ PointGFp_Base_Point_Precompute::PointGFp_Base_Point_Precompute(const PointGFp& b
       g.mult2(ws);
       }
 
-   PointGFp::force_all_affine(T, ws[0].get_word_vector());
+   EC_Point::force_all_affine(T, ws[0].get_word_vector());
 
    m_W.resize(T.size() * 2 * m_p_words);
 
@@ -83,13 +83,13 @@ PointGFp_Base_Point_Precompute::PointGFp_Base_Point_Precompute(const PointGFp& b
       }
    }
 
-PointGFp PointGFp_Base_Point_Precompute::mul(const BigInt& k,
+EC_Point EC_Point_Base_Point_Precompute::mul(const BigInt& k,
                                              RandomNumberGenerator& rng,
                                              const BigInt& group_order,
                                              std::vector<BigInt>& ws) const
    {
    if(k.is_negative())
-      throw Invalid_Argument("PointGFp_Base_Point_Precompute scalar must be positive");
+      throw Invalid_Argument("EC_Point_Base_Point_Precompute scalar must be positive");
 
    // Instead of reducing k mod group order should we alter the mask size??
    BigInt scalar = m_mod_order.reduce(k);
@@ -121,10 +121,10 @@ PointGFp PointGFp_Base_Point_Precompute::mul(const BigInt& k,
    BOTAN_ASSERT(windows <= m_W.size() / (3*elem_size),
                 "Precomputed sufficient values for scalar mult");
 
-   PointGFp R = m_base_point.zero();
+   EC_Point R = m_base_point.zero();
 
-   if(ws.size() < PointGFp::WORKSPACE_SIZE)
-      ws.resize(PointGFp::WORKSPACE_SIZE);
+   if(ws.size() < EC_Point::WORKSPACE_SIZE)
+      ws.resize(EC_Point::WORKSPACE_SIZE);
 
    // the precomputed multiples are not secret so use std::vector
    std::vector<word> Wt(elem_size);
@@ -176,17 +176,17 @@ PointGFp PointGFp_Base_Point_Precompute::mul(const BigInt& k,
    return R;
    }
 
-PointGFp_Var_Point_Precompute::PointGFp_Var_Point_Precompute(const PointGFp& point,
+EC_Point_Var_Point_Precompute::EC_Point_Var_Point_Precompute(const EC_Point& point,
                                                              RandomNumberGenerator& rng,
                                                              std::vector<BigInt>& ws) :
    m_curve(point.get_curve()),
    m_p_words(m_curve.get_p().sig_words()),
    m_window_bits(4)
    {
-   if(ws.size() < PointGFp::WORKSPACE_SIZE)
-      ws.resize(PointGFp::WORKSPACE_SIZE);
+   if(ws.size() < EC_Point::WORKSPACE_SIZE)
+      ws.resize(EC_Point::WORKSPACE_SIZE);
 
-   std::vector<PointGFp> U(static_cast<size_t>(1) << m_window_bits);
+   std::vector<EC_Point> U(static_cast<size_t>(1) << m_window_bits);
    U[0] = point.zero();
    U[1] = point;
 
@@ -241,15 +241,15 @@ PointGFp_Var_Point_Precompute::PointGFp_Var_Point_Precompute(const PointGFp& poi
       }
    }
 
-PointGFp PointGFp_Var_Point_Precompute::mul(const BigInt& k,
+EC_Point EC_Point_Var_Point_Precompute::mul(const BigInt& k,
                                             RandomNumberGenerator& rng,
                                             const BigInt& group_order,
                                             std::vector<BigInt>& ws) const
    {
    if(k.is_negative())
-      throw Invalid_Argument("PointGFp_Var_Point_Precompute scalar must be positive");
-   if(ws.size() < PointGFp::WORKSPACE_SIZE)
-      ws.resize(PointGFp::WORKSPACE_SIZE);
+      throw Invalid_Argument("EC_Point_Var_Point_Precompute scalar must be positive");
+   if(ws.size() < EC_Point::WORKSPACE_SIZE)
+      ws.resize(EC_Point::WORKSPACE_SIZE);
 
    // Choose a small mask m and use k' = k + m*order (Coron's 1st countermeasure)
    const BigInt mask(rng, blinding_size(group_order), false);
@@ -259,7 +259,7 @@ PointGFp PointGFp_Var_Point_Precompute::mul(const BigInt& k,
    const size_t window_elems = static_cast<size_t>(1) << m_window_bits;
 
    size_t windows = round_up(scalar.bits(), m_window_bits) / m_window_bits;
-   PointGFp R(m_curve);
+   EC_Point R(m_curve);
    secure_vector<word> e(elem_size);
 
    if(windows > 0)
@@ -317,8 +317,8 @@ PointGFp PointGFp_Var_Point_Precompute::mul(const BigInt& k,
    }
 
 
-PointGFp_Multi_Point_Precompute::PointGFp_Multi_Point_Precompute(const PointGFp& x,
-                                                                 const PointGFp& y)
+EC_Point_Multi_Point_Precompute::EC_Point_Multi_Point_Precompute(const EC_Point& x,
+                                                                 const EC_Point& y)
    {
    if(x.on_the_curve() == false || y.on_the_curve() == false)
       {
@@ -326,17 +326,17 @@ PointGFp_Multi_Point_Precompute::PointGFp_Multi_Point_Precompute(const PointGFp&
       return;
       }
 
-   std::vector<BigInt> ws(PointGFp::WORKSPACE_SIZE);
+   std::vector<BigInt> ws(EC_Point::WORKSPACE_SIZE);
 
-   PointGFp x2 = x;
+   EC_Point x2 = x;
    x2.mult2(ws);
 
-   const PointGFp x3(x2.plus(x, ws));
+   const EC_Point x3(x2.plus(x, ws));
 
-   PointGFp y2 = y;
+   EC_Point y2 = y;
    y2.mult2(ws);
 
-   const PointGFp y3(y2.plus(y, ws));
+   const EC_Point y3(y2.plus(y, ws));
 
    m_M.reserve(15);
 
@@ -368,23 +368,23 @@ PointGFp_Multi_Point_Precompute::PointGFp_Multi_Point_Precompute(const PointGFp&
 
    if(no_infinity)
       {
-      PointGFp::force_all_affine(m_M, ws[0].get_word_vector());
+      EC_Point::force_all_affine(m_M, ws[0].get_word_vector());
       }
 
    m_no_infinity = no_infinity;
    }
 
-PointGFp PointGFp_Multi_Point_Precompute::multi_exp(const BigInt& z1,
+EC_Point EC_Point_Multi_Point_Precompute::multi_exp(const BigInt& z1,
                                                     const BigInt& z2) const
    {
    if(m_M.size() == 1)
       return m_M[0];
 
-   std::vector<BigInt> ws(PointGFp::WORKSPACE_SIZE);
+   std::vector<BigInt> ws(EC_Point::WORKSPACE_SIZE);
 
    const size_t z_bits = round_up(std::max(z1.bits(), z2.bits()), 2);
 
-   PointGFp H = m_M[0].zero();
+   EC_Point H = m_M[0].zero();
 
    for(size_t i = 0; i != z_bits; i += 2)
       {
diff --git a/src/lib/pubkey/ec_group/point_mul.h b/src/lib/pubkey/ec_group/point_mul.h
index 095620428..ffae2c5ab 100644
--- a/src/lib/pubkey/ec_group/point_mul.h
+++ b/src/lib/pubkey/ec_group/point_mul.h
@@ -7,24 +7,24 @@
 #ifndef BOTAN_POINT_MUL_H_
 #define BOTAN_POINT_MUL_H_
 
-#include <botan/point_gfp.h>
+#include <botan/ec_point.h>
 
 namespace Botan {
 
 class Modular_Reducer;
 
-class PointGFp_Base_Point_Precompute final
+class EC_Point_Base_Point_Precompute final
    {
    public:
-      PointGFp_Base_Point_Precompute(const PointGFp& base_point,
+      EC_Point_Base_Point_Precompute(const EC_Point& base_point,
                                      const Modular_Reducer& mod_order);
 
-      PointGFp mul(const BigInt& k,
+      EC_Point mul(const BigInt& k,
                    RandomNumberGenerator& rng,
                    const BigInt& group_order,
                    std::vector<BigInt>& ws) const;
    private:
-      const PointGFp& m_base_point;
+      const EC_Point& m_base_point;
       const Modular_Reducer& m_mod_order;
 
       enum { WINDOW_BITS = 3 };
@@ -38,14 +38,14 @@ class PointGFp_Base_Point_Precompute final
       std::vector<word> m_W;
    };
 
-class PointGFp_Var_Point_Precompute final
+class EC_Point_Var_Point_Precompute final
    {
    public:
-      PointGFp_Var_Point_Precompute(const PointGFp& point,
+      EC_Point_Var_Point_Precompute(const EC_Point& point,
                                     RandomNumberGenerator& rng,
                                     std::vector<BigInt>& ws);
 
-      PointGFp mul(const BigInt& k,
+      EC_Point mul(const BigInt& k,
                    RandomNumberGenerator& rng,
                    const BigInt& group_order,
                    std::vector<BigInt>& ws) const;
@@ -63,20 +63,20 @@ class PointGFp_Var_Point_Precompute final
       secure_vector<word> m_T;
    };
 
-class PointGFp_Multi_Point_Precompute final
+class EC_Point_Multi_Point_Precompute final
    {
    public:
-      PointGFp_Multi_Point_Precompute(const PointGFp& g1,
-                                      const PointGFp& g2);
+      EC_Point_Multi_Point_Precompute(const EC_Point& g1,
+                                      const EC_Point& g2);
 
       /*
       * Return (g1*k1 + g2*k2)
       * Not constant time, intended to use with public inputs
       */
-      PointGFp multi_exp(const BigInt& k1,
+      EC_Point multi_exp(const BigInt& k1,
                          const BigInt& k2) const;
    private:
-      std::vector<PointGFp> m_M;
+      std::vector<EC_Point> m_M;
       bool m_no_infinity;
    };
 
diff --git a/src/lib/pubkey/ec_h2c/ec_h2c.cpp b/src/lib/pubkey/ec_h2c/ec_h2c.cpp
index d2e79a316..968b8c247 100644
--- a/src/lib/pubkey/ec_h2c/ec_h2c.cpp
+++ b/src/lib/pubkey/ec_h2c/ec_h2c.cpp
@@ -126,7 +126,7 @@ BigInt ct_choose(bool first, const BigInt& x, const BigInt& y)
    return z;
    }
 
-PointGFp map_to_curve_sswu(const EC_Group& group, const Modular_Reducer& mod_p, const BigInt& u)
+EC_Point map_to_curve_sswu(const EC_Group& group, const Modular_Reducer& mod_p, const BigInt& u)
    {
    const BigInt& p = group.get_p();
    const BigInt& A = group.get_a();
@@ -181,7 +181,7 @@ PointGFp map_to_curve_sswu(const EC_Group& group, const Modular_Reducer& mod_p,
 
 }
 
-PointGFp hash_to_curve_sswu(const EC_Group& group,
+EC_Point hash_to_curve_sswu(const EC_Group& group,
                             const std::string& hash_fn,
                             const uint8_t input[],
                             size_t input_len,
@@ -197,7 +197,7 @@ PointGFp hash_to_curve_sswu(const EC_Group& group,
                                 input, input_len,
                                 domain_sep, domain_sep_len);
 
-   PointGFp pt = map_to_curve_sswu(group, mod_p, u[0]);
+   EC_Point pt = map_to_curve_sswu(group, mod_p, u[0]);
 
    for(size_t i = 1; i != u.size(); ++i)
       pt += map_to_curve_sswu(group, mod_p, u[i]);
diff --git a/src/lib/pubkey/ec_h2c/ec_h2c.h b/src/lib/pubkey/ec_h2c/ec_h2c.h
index f932e76a5..8dba5dbc8 100644
--- a/src/lib/pubkey/ec_h2c/ec_h2c.h
+++ b/src/lib/pubkey/ec_h2c/ec_h2c.h
@@ -8,7 +8,7 @@
 #define BOTAN_ECC_HASH_TO_CURVE_H_
 
 #include <botan/types.h>
-#include <botan/point_gfp.h>
+#include <botan/ec_point.h>
 #include <string>
 
 namespace Botan {
@@ -34,7 +34,7 @@ void BOTAN_TEST_API expand_message_xmd(const std::string& hash_fn,
 * This method requires that the ECC group have (a*b) != 0
 * which excludes certain groups including secp256k1
 */
-PointGFp hash_to_curve_sswu(const EC_Group& group,
+EC_Point hash_to_curve_sswu(const EC_Group& group,
                             const std::string& hash_fn,
                             const uint8_t input[],
                             size_t input_len,
diff --git a/src/lib/pubkey/ecc_key/ecc_key.cpp b/src/lib/pubkey/ecc_key/ecc_key.cpp
index d5afbbf07..67d526c25 100644
--- a/src/lib/pubkey/ecc_key/ecc_key.cpp
+++ b/src/lib/pubkey/ecc_key/ecc_key.cpp
@@ -12,7 +12,7 @@
 #include <botan/der_enc.h>
 #include <botan/ber_dec.h>
 #include <botan/secmem.h>
-#include <botan/point_gfp.h>
+#include <botan/ec_point.h>
 #include <botan/internal/workfactor.h>
 
 namespace Botan {
@@ -40,7 +40,7 @@ EC_Group_Encoding default_encoding_for(EC_Group& group)
 }
 
 EC_PublicKey::EC_PublicKey(const EC_Group& dom_par,
-                           const PointGFp& pub_point) :
+                           const EC_Point& pub_point) :
    m_domain_params(dom_par),
    m_public_key(pub_point),
    m_domain_encoding(default_encoding_for(m_domain_params))
@@ -77,11 +77,11 @@ std::vector<uint8_t> EC_PublicKey::public_key_bits() const
    return public_point().encode(point_encoding());
    }
 
-void EC_PublicKey::set_point_encoding(PointGFp::Compression_Type enc)
+void EC_PublicKey::set_point_encoding(EC_Point::Compression_Type enc)
    {
-   if(enc != PointGFp::COMPRESSED &&
-      enc != PointGFp::UNCOMPRESSED &&
-      enc != PointGFp::HYBRID)
+   if(enc != EC_Point::COMPRESSED &&
+      enc != EC_Point::UNCOMPRESSED &&
+      enc != EC_Point::HYBRID)
       throw Invalid_Argument("Invalid point encoding for EC_PublicKey");
 
    m_point_encoding = enc;
@@ -147,7 +147,7 @@ secure_vector<uint8_t> EC_PrivateKey::private_key_bits() const
          .encode(static_cast<size_t>(1))
          .encode(BigInt::encode_1363(m_private_key, m_private_key.bytes()), ASN1_Type::OctetString)
          .start_explicit_context_specific(1)
-            .encode(m_public_key.encode(PointGFp::Compression_Type::UNCOMPRESSED), ASN1_Type::BitString)
+            .encode(m_public_key.encode(EC_Point::Compression_Type::UNCOMPRESSED), ASN1_Type::BitString)
          .end_cons()
       .end_cons()
       .get_contents();
diff --git a/src/lib/pubkey/ecc_key/ecc_key.h b/src/lib/pubkey/ecc_key/ecc_key.h
index 9969700fb..271cca665 100644
--- a/src/lib/pubkey/ecc_key/ecc_key.h
+++ b/src/lib/pubkey/ecc_key/ecc_key.h
@@ -38,7 +38,7 @@ class BOTAN_PUBLIC_API(2,0) EC_PublicKey : public virtual Public_Key
       * domain parameters of this point are not set
       * @result the public point of this key
       */
-      const PointGFp& public_point() const { return m_public_key; }
+      const EC_Point& public_point() const { return m_public_key; }
 
       AlgorithmIdentifier algorithm_identifier() const override;
 
@@ -65,7 +65,7 @@ class BOTAN_PUBLIC_API(2,0) EC_PublicKey : public virtual Public_Key
       * Set the point encoding method to be used when encoding this key.
       * @param enc the encoding to use
       */
-      void set_point_encoding(PointGFp::Compression_Type enc);
+      void set_point_encoding(EC_Point::Compression_Type enc);
 
       /**
       * Return the DER encoding of this keys domain in whatever format
@@ -85,7 +85,7 @@ class BOTAN_PUBLIC_API(2,0) EC_PublicKey : public virtual Public_Key
       * Get the point encoding method to be used when encoding this key.
       * @result the encoding to use
       */
-      PointGFp::Compression_Type point_encoding() const
+      EC_Point::Compression_Type point_encoding() const
          { return m_point_encoding; }
 
       size_t key_length() const override;
@@ -98,7 +98,7 @@ class BOTAN_PUBLIC_API(2,0) EC_PublicKey : public virtual Public_Key
       * @param pub_point public point on the curve
       */
       EC_PublicKey(const EC_Group& dom_par,
-                   const PointGFp& pub_point);
+                   const EC_Point& pub_point);
 
       /**
       * Load a public key.
@@ -112,9 +112,9 @@ class BOTAN_PUBLIC_API(2,0) EC_PublicKey : public virtual Public_Key
       {}
 
       EC_Group m_domain_params;
-      PointGFp m_public_key;
+      EC_Point m_public_key;
       EC_Group_Encoding m_domain_encoding;
-      PointGFp::Compression_Type m_point_encoding = PointGFp::UNCOMPRESSED;
+      EC_Point::Compression_Type m_point_encoding = EC_Point::UNCOMPRESSED;
    };
 
 /**
diff --git a/src/lib/pubkey/ecdh/ecdh.cpp b/src/lib/pubkey/ecdh/ecdh.cpp
index 585bc4a87..0a6474b96 100644
--- a/src/lib/pubkey/ecdh/ecdh.cpp
+++ b/src/lib/pubkey/ecdh/ecdh.cpp
@@ -39,10 +39,10 @@ class ECDH_KA_Operation final : public PK_Ops::Key_Agreement_with_KDF
 
       secure_vector<uint8_t> raw_agree(const uint8_t w[], size_t w_len) override
          {
-         PointGFp input_point = m_group.get_cofactor() * m_group.OS2ECP(w, w_len);
+         EC_Point input_point = m_group.get_cofactor() * m_group.OS2ECP(w, w_len);
          input_point.randomize_repr(m_rng);
 
-         const PointGFp S = m_group.blinded_var_point_multiply(
+         const EC_Point S = m_group.blinded_var_point_multiply(
             input_point, m_l_times_priv, m_rng, m_ws);
 
          if(S.on_the_curve() == false)
diff --git a/src/lib/pubkey/ecdh/ecdh.h b/src/lib/pubkey/ecdh/ecdh.h
index 4a6061e1a..328ab884c 100644
--- a/src/lib/pubkey/ecdh/ecdh.h
+++ b/src/lib/pubkey/ecdh/ecdh.h
@@ -35,7 +35,7 @@ class BOTAN_PUBLIC_API(2,0) ECDH_PublicKey : public virtual EC_PublicKey
       * @param public_point the public point defining this key
       */
       ECDH_PublicKey(const EC_Group& dom_par,
-                     const PointGFp& public_point) :
+                     const EC_Point& public_point) :
          EC_PublicKey(dom_par, public_point) {}
 
       /**
@@ -48,12 +48,12 @@ class BOTAN_PUBLIC_API(2,0) ECDH_PublicKey : public virtual EC_PublicKey
       * @return public point value
       */
       std::vector<uint8_t> public_value() const
-         { return public_point().encode(PointGFp::UNCOMPRESSED); }
+         { return public_point().encode(EC_Point::UNCOMPRESSED); }
 
       /**
       * @return public point value
       */
-      std::vector<uint8_t> public_value(PointGFp::Compression_Type format) const
+      std::vector<uint8_t> public_value(EC_Point::Compression_Type format) const
          { return public_point().encode(format); }
 
    protected:
@@ -92,9 +92,9 @@ class BOTAN_PUBLIC_API(2,0) ECDH_PrivateKey final : public ECDH_PublicKey,
       std::unique_ptr<Public_Key> public_key() const override;
 
       std::vector<uint8_t> public_value() const override
-         { return ECDH_PublicKey::public_value(PointGFp::UNCOMPRESSED); }
+         { return ECDH_PublicKey::public_value(EC_Point::UNCOMPRESSED); }
 
-      std::vector<uint8_t> public_value(PointGFp::Compression_Type type) const
+      std::vector<uint8_t> public_value(EC_Point::Compression_Type type) const
          { return ECDH_PublicKey::public_value(type); }
 
       std::unique_ptr<PK_Ops::Key_Agreement>
diff --git a/src/lib/pubkey/ecdsa/ecdsa.cpp b/src/lib/pubkey/ecdsa/ecdsa.cpp
index 9b17b183e..c7b6be6ca 100644
--- a/src/lib/pubkey/ecdsa/ecdsa.cpp
+++ b/src/lib/pubkey/ecdsa/ecdsa.cpp
@@ -23,7 +23,7 @@ namespace Botan {
 
 namespace {
 
-PointGFp recover_ecdsa_public_key(const EC_Group& group,
+EC_Point recover_ecdsa_public_key(const EC_Group& group,
                                   const std::vector<uint8_t>& msg,
                                   const BigInt& r,
                                   const BigInt& s,
@@ -58,13 +58,13 @@ PointGFp recover_ecdsa_public_key(const EC_Group& group,
       X[0] = 0x02 | y_odd;
       BigInt::encode_1363(&X[1], p_bytes, x);
 
-      const PointGFp R = group.OS2ECP(X);
+      const EC_Point R = group.OS2ECP(X);
 
       if((R*group_order).is_zero() == false)
          throw Decoding_Error("Unable to recover ECDSA public key");
 
       // Compute r_inv * (s*R - eG)
-      PointGFp_Multi_Point_Precompute RG_mul(R, group.get_base_point());
+      EC_Point_Multi_Point_Precompute RG_mul(R, group.get_base_point());
       const BigInt ne = group.mod_order(group_order - e);
       return r_inv * RG_mul.multi_exp(s, ne);
       }
@@ -94,7 +94,7 @@ uint8_t ECDSA_PublicKey::recovery_param(const std::vector<uint8_t>& msg,
       {
       try
          {
-         PointGFp R = recover_ecdsa_public_key(this->domain(), msg, r, s, v);
+         EC_Point R = recover_ecdsa_public_key(this->domain(), msg, r, s, v);
 
          if(R == this->public_point())
             {
@@ -228,7 +228,7 @@ class ECDSA_Verification_Operation final : public PK_Ops::Verification_with_EMSA
                   const uint8_t sig[], size_t sig_len) override;
    private:
       const EC_Group m_group;
-      const PointGFp_Multi_Point_Precompute m_gy_mul;
+      const EC_Point_Multi_Point_Precompute m_gy_mul;
    };
 
 bool ECDSA_Verification_Operation::verify(const uint8_t msg[], size_t msg_len,
@@ -253,7 +253,7 @@ bool ECDSA_Verification_Operation::verify(const uint8_t msg[], size_t msg_len,
 
    const BigInt u1 = m_group.multiply_mod_order(m_group.mod_order(e), w);
    const BigInt u2 = m_group.multiply_mod_order(r, w);
-   const PointGFp R = m_gy_mul.multi_exp(u1, u2);
+   const EC_Point R = m_gy_mul.multi_exp(u1, u2);
 
    if(R.is_zero())
       return false;
diff --git a/src/lib/pubkey/ecdsa/ecdsa.h b/src/lib/pubkey/ecdsa/ecdsa.h
index 581d024e9..c5eeb0704 100644
--- a/src/lib/pubkey/ecdsa/ecdsa.h
+++ b/src/lib/pubkey/ecdsa/ecdsa.h
@@ -27,7 +27,7 @@ class BOTAN_PUBLIC_API(2,0) ECDSA_PublicKey : public virtual EC_PublicKey
       * @param public_point the public point defining this key
       */
       ECDSA_PublicKey(const EC_Group& dom_par,
-                      const PointGFp& public_point) :
+                      const EC_Point& public_point) :
          EC_PublicKey(dom_par, public_point) {}
 
       /**
diff --git a/src/lib/pubkey/ecgdsa/ecgdsa.cpp b/src/lib/pubkey/ecgdsa/ecgdsa.cpp
index 073f4e91a..68ff9e7fe 100644
--- a/src/lib/pubkey/ecgdsa/ecgdsa.cpp
+++ b/src/lib/pubkey/ecgdsa/ecgdsa.cpp
@@ -106,7 +106,7 @@ class ECGDSA_Verification_Operation final : public PK_Ops::Verification_with_EMS
                   const uint8_t sig[], size_t sig_len) override;
    private:
       const EC_Group m_group;
-      const PointGFp_Multi_Point_Precompute m_gy_mul;
+      const EC_Point_Multi_Point_Precompute m_gy_mul;
    };
 
 bool ECGDSA_Verification_Operation::verify(const uint8_t msg[], size_t msg_len,
@@ -127,7 +127,7 @@ bool ECGDSA_Verification_Operation::verify(const uint8_t msg[], size_t msg_len,
 
    const BigInt u1 = m_group.multiply_mod_order(e, w);
    const BigInt u2 = m_group.multiply_mod_order(s, w);
-   const PointGFp R = m_gy_mul.multi_exp(u1, u2);
+   const EC_Point R = m_gy_mul.multi_exp(u1, u2);
 
    if(R.is_zero())
       return false;
diff --git a/src/lib/pubkey/ecgdsa/ecgdsa.h b/src/lib/pubkey/ecgdsa/ecgdsa.h
index ea8e912a3..98eb80ab9 100644
--- a/src/lib/pubkey/ecgdsa/ecgdsa.h
+++ b/src/lib/pubkey/ecgdsa/ecgdsa.h
@@ -25,7 +25,7 @@ class BOTAN_PUBLIC_API(2,0) ECGDSA_PublicKey : public virtual EC_PublicKey
       * @param public_point the public point defining this key
       */
       ECGDSA_PublicKey(const EC_Group& dom_par,
-                      const PointGFp& public_point) :
+                      const EC_Point& public_point) :
          EC_PublicKey(dom_par, public_point) {}
 
       /**
diff --git a/src/lib/pubkey/ecies/ecies.cpp b/src/lib/pubkey/ecies/ecies.cpp
index 7a98fbf6e..a1142c369 100644
--- a/src/lib/pubkey/ecies/ecies.cpp
+++ b/src/lib/pubkey/ecies/ecies.cpp
@@ -73,10 +73,10 @@ class ECIES_ECDH_KA_Operation final : public PK_Ops::Key_Agreement_with_KDF
          {
          const EC_Group& group = m_key.domain();
 
-         PointGFp input_point = group.OS2ECP(w, w_len);
+         EC_Point input_point = group.OS2ECP(w, w_len);
          input_point.randomize_repr(m_rng);
 
-         const PointGFp S = group.blinded_var_point_multiply(
+         const EC_Point S = group.blinded_var_point_multiply(
             input_point, m_key.private_value(), m_rng, m_ws);
 
          if(S.on_the_curve() == false)
@@ -147,7 +147,7 @@ ECIES_KA_Operation::ECIES_KA_Operation(const PK_Key_Agreement_Key& private_key,
 * ECIES secret derivation according to ISO 18033-2
 */
 SymmetricKey ECIES_KA_Operation::derive_secret(const std::vector<uint8_t>& eph_public_key_bin,
-      const PointGFp& other_public_key_point) const
+      const EC_Point& other_public_key_point) const
    {
    if(other_public_key_point.is_zero())
       {
@@ -156,7 +156,7 @@ SymmetricKey ECIES_KA_Operation::derive_secret(const std::vector<uint8_t>& eph_p
 
    std::unique_ptr<KDF> kdf = KDF::create_or_throw(m_params.kdf_spec());
 
-   PointGFp other_point = other_public_key_point;
+   EC_Point other_point = other_public_key_point;
 
    // ISO 18033: step b
    if(m_params.old_cofactor_mode())
@@ -185,7 +185,7 @@ SymmetricKey ECIES_KA_Operation::derive_secret(const std::vector<uint8_t>& eph_p
 
 
 ECIES_KA_Params::ECIES_KA_Params(const EC_Group& domain, const std::string& kdf_spec, size_t length,
-                                 PointGFp::Compression_Type compression_type, ECIES_Flags flags) :
+                                 EC_Point::Compression_Type compression_type, ECIES_Flags flags) :
    m_domain(domain),
    m_kdf_spec(kdf_spec),
    m_length(length),
@@ -197,7 +197,7 @@ ECIES_KA_Params::ECIES_KA_Params(const EC_Group& domain, const std::string& kdf_
 ECIES_System_Params::ECIES_System_Params(const EC_Group& domain, const std::string& kdf_spec,
                                          const std::string& dem_algo_spec, size_t dem_key_len,
                                          const std::string& mac_spec, size_t mac_key_len,
-                                         PointGFp::Compression_Type compression_type, ECIES_Flags flags) :
+                                         EC_Point::Compression_Type compression_type, ECIES_Flags flags) :
    ECIES_KA_Params(domain, kdf_spec, dem_key_len + mac_key_len, compression_type, flags),
    m_dem_spec(dem_algo_spec),
    m_dem_keylen(dem_key_len),
@@ -214,7 +214,7 @@ ECIES_System_Params::ECIES_System_Params(const EC_Group& domain, const std::stri
 ECIES_System_Params::ECIES_System_Params(const EC_Group& domain, const std::string& kdf_spec,
                                          const std::string& dem_algo_spec, size_t dem_key_len,
                                          const std::string& mac_spec, size_t mac_key_len) :
-   ECIES_System_Params(domain, kdf_spec, dem_algo_spec, dem_key_len, mac_spec, mac_key_len, PointGFp::UNCOMPRESSED,
+   ECIES_System_Params(domain, kdf_spec, dem_algo_spec, dem_key_len, mac_spec, mac_key_len, EC_Point::UNCOMPRESSED,
                          ECIES_Flags::NONE)
    {
    }
@@ -243,7 +243,7 @@ ECIES_Encryptor::ECIES_Encryptor(const PK_Key_Agreement_Key& private_key,
    m_other_point(),
    m_label()
    {
-   if(ecies_params.compression_type() != PointGFp::UNCOMPRESSED)
+   if(ecies_params.compression_type() != EC_Point::UNCOMPRESSED)
       {
       // ISO 18033: step d
       // convert only if necessary; m_eph_public_key_bin has been initialized with the uncompressed format
@@ -370,7 +370,7 @@ secure_vector<uint8_t> ECIES_Decryptor::do_decrypt(uint8_t& valid_mask, const ui
    const std::vector<uint8_t> mac_data(in + in_len - m_mac->output_length(), in + in_len);
 
    // ISO 18033: step a
-   PointGFp other_public_key = m_params.domain().OS2ECP(other_public_key_bin);
+   EC_Point other_public_key = m_params.domain().OS2ECP(other_public_key_bin);
 
    // ISO 18033: step b
    if(m_params.check_mode() && !other_public_key.on_the_curve())
diff --git a/src/lib/pubkey/ecies/ecies.h b/src/lib/pubkey/ecies/ecies.h
index af2a0c312..8e9f684a5 100644
--- a/src/lib/pubkey/ecies/ecies.h
+++ b/src/lib/pubkey/ecies/ecies.h
@@ -11,7 +11,7 @@
 #include <botan/ecdh.h>
 #include <botan/ec_group.h>
 #include <botan/cipher_mode.h>
-#include <botan/point_gfp.h>
+#include <botan/ec_point.h>
 #include <botan/pubkey.h>
 #include <botan/secmem.h>
 #include <botan/symkey.h>
@@ -65,7 +65,7 @@ class BOTAN_PUBLIC_API(2,0) ECIES_KA_Params
       * @param flags options, see documentation of ECIES_Flags
       */
       ECIES_KA_Params(const EC_Group& domain, const std::string& kdf_spec, size_t length,
-                      PointGFp::Compression_Type compression_type, ECIES_Flags flags);
+                      EC_Point::Compression_Type compression_type, ECIES_Flags flags);
 
       ECIES_KA_Params(const ECIES_KA_Params&) = default;
       ECIES_KA_Params& operator=(const ECIES_KA_Params&) = delete;
@@ -102,7 +102,7 @@ class BOTAN_PUBLIC_API(2,0) ECIES_KA_Params
          return (m_flags & ECIES_Flags::CHECK_MODE) == ECIES_Flags::CHECK_MODE;
          }
 
-      inline PointGFp::Compression_Type compression_type() const
+      inline EC_Point::Compression_Type compression_type() const
          {
          return m_compression_mode;
          }
@@ -116,7 +116,7 @@ class BOTAN_PUBLIC_API(2,0) ECIES_KA_Params
       const EC_Group m_domain;
       const std::string m_kdf_spec;
       const size_t m_length;
-      const PointGFp::Compression_Type m_compression_mode;
+      const EC_Point::Compression_Type m_compression_mode;
       const ECIES_Flags m_flags;
    };
 
@@ -147,7 +147,7 @@ class BOTAN_PUBLIC_API(2,0) ECIES_System_Params final : public ECIES_KA_Params
       */
       ECIES_System_Params(const EC_Group& domain, const std::string& kdf_spec, const std::string& dem_algo_spec,
                           size_t dem_key_len, const std::string& mac_spec, size_t mac_key_len,
-                          PointGFp::Compression_Type compression_type, ECIES_Flags flags);
+                          EC_Point::Compression_Type compression_type, ECIES_Flags flags);
 
       ECIES_System_Params(const ECIES_System_Params&) = default;
       ECIES_System_Params& operator=(const ECIES_System_Params&) = delete;
@@ -203,7 +203,7 @@ class BOTAN_PUBLIC_API(2,0) ECIES_KA_Operation
       * @param other_public_key_point public key point of the other party
       */
       SymmetricKey derive_secret(const std::vector<uint8_t>& eph_public_key_bin,
-                                 const PointGFp& other_public_key_point) const;
+                                 const EC_Point& other_public_key_point) const;
 
    private:
       const PK_Key_Agreement m_ka;
@@ -234,7 +234,7 @@ class BOTAN_PUBLIC_API(2,0) ECIES_Encryptor final : public PK_Encryptor
       ECIES_Encryptor(RandomNumberGenerator& rng, const ECIES_System_Params& ecies_params);
 
       /// Set the public key of the other party
-      inline void set_other_key(const PointGFp& public_point)
+      inline void set_other_key(const EC_Point& public_point)
          {
          m_other_point = public_point;
          }
@@ -264,7 +264,7 @@ class BOTAN_PUBLIC_API(2,0) ECIES_Encryptor final : public PK_Encryptor
       std::unique_ptr<Cipher_Mode> m_cipher;
       std::vector<uint8_t> m_eph_public_key_bin;
       InitializationVector m_iv;
-      PointGFp m_other_point;
+      EC_Point m_other_point;
       std::vector<uint8_t> m_label;
    };
 
diff --git a/src/lib/pubkey/eckcdsa/eckcdsa.cpp b/src/lib/pubkey/eckcdsa/eckcdsa.cpp
index 2be547545..fa5a86769 100644
--- a/src/lib/pubkey/eckcdsa/eckcdsa.cpp
+++ b/src/lib/pubkey/eckcdsa/eckcdsa.cpp
@@ -170,7 +170,7 @@ class ECKCDSA_Verification_Operation final : public PK_Ops::Verification_with_EM
                   const uint8_t sig[], size_t sig_len) override;
    private:
       const EC_Group m_group;
-      const PointGFp_Multi_Point_Precompute m_gy_mul;
+      const EC_Point_Multi_Point_Precompute m_gy_mul;
       secure_vector<uint8_t> m_prefix;
    };
 
@@ -203,7 +203,7 @@ bool ECKCDSA_Verification_Operation::verify(const uint8_t msg[], size_t /*msg_le
    BigInt w(r_xor_e.data(), r_xor_e.size());
    w = m_group.mod_order(w);
 
-   const PointGFp q = m_gy_mul.multi_exp(w, s);
+   const EC_Point q = m_gy_mul.multi_exp(w, s);
    if(q.is_zero())
       {
       return false;
diff --git a/src/lib/pubkey/eckcdsa/eckcdsa.h b/src/lib/pubkey/eckcdsa/eckcdsa.h
index ebf5ada30..f6af431d0 100644
--- a/src/lib/pubkey/eckcdsa/eckcdsa.h
+++ b/src/lib/pubkey/eckcdsa/eckcdsa.h
@@ -25,7 +25,7 @@ class BOTAN_PUBLIC_API(2,0) ECKCDSA_PublicKey : public virtual EC_PublicKey
       * @param public_point the public point defining this key
       */
       ECKCDSA_PublicKey(const EC_Group& dom_par,
-                      const PointGFp& public_point) :
+                      const EC_Point& public_point) :
          EC_PublicKey(dom_par, public_point) {}
 
       /**
diff --git a/src/lib/pubkey/gost_3410/gost_3410.cpp b/src/lib/pubkey/gost_3410/gost_3410.cpp
index 8ae2dea90..09db1f5a7 100644
--- a/src/lib/pubkey/gost_3410/gost_3410.cpp
+++ b/src/lib/pubkey/gost_3410/gost_3410.cpp
@@ -202,7 +202,7 @@ class GOST_3410_Verification_Operation final : public PK_Ops::Verification_with_
                   const uint8_t sig[], size_t sig_len) override;
    private:
       const EC_Group m_group;
-      const PointGFp_Multi_Point_Precompute m_gy_mul;
+      const EC_Point_Multi_Point_Precompute m_gy_mul;
    };
 
 bool GOST_3410_Verification_Operation::verify(const uint8_t msg[], size_t msg_len,
@@ -229,7 +229,7 @@ bool GOST_3410_Verification_Operation::verify(const uint8_t msg[], size_t msg_le
    const BigInt z1 = m_group.multiply_mod_order(s, v);
    const BigInt z2 = m_group.multiply_mod_order(-r, v);
 
-   const PointGFp R = m_gy_mul.multi_exp(z1, z2);
+   const EC_Point R = m_gy_mul.multi_exp(z1, z2);
 
    if(R.is_zero())
      return false;
diff --git a/src/lib/pubkey/gost_3410/gost_3410.h b/src/lib/pubkey/gost_3410/gost_3410.h
index ecaf0aa36..0e3b8ce47 100644
--- a/src/lib/pubkey/gost_3410/gost_3410.h
+++ b/src/lib/pubkey/gost_3410/gost_3410.h
@@ -27,7 +27,7 @@ class BOTAN_PUBLIC_API(2,0) GOST_3410_PublicKey : public virtual EC_PublicKey
       * @param public_point the public point defining this key
       */
       GOST_3410_PublicKey(const EC_Group& dom_par,
-                          const PointGFp& public_point) :
+                          const EC_Point& public_point) :
          EC_PublicKey(dom_par, public_point) {}
 
       /**
diff --git a/src/lib/pubkey/sm2/sm2.cpp b/src/lib/pubkey/sm2/sm2.cpp
index a25aa1516..df8ffb880 100644
--- a/src/lib/pubkey/sm2/sm2.cpp
+++ b/src/lib/pubkey/sm2/sm2.cpp
@@ -57,7 +57,7 @@ SM2_PrivateKey::SM2_PrivateKey(RandomNumberGenerator& rng,
 std::vector<uint8_t> sm2_compute_za(HashFunction& hash,
                                     const std::string& user_id,
                                     const EC_Group& domain,
-                                    const PointGFp& pubkey)
+                                    const EC_Point& pubkey)
    {
    if(user_id.size() >= 8192)
       throw Invalid_Argument("SM2 user id too long to represent");
@@ -204,7 +204,7 @@ class SM2_Verification_Operation final : public PK_Ops::Verification
       bool is_valid_signature(const uint8_t sig[], size_t sig_len) override;
    private:
       const EC_Group m_group;
-      const PointGFp_Multi_Point_Precompute m_gy_mul;
+      const EC_Point_Multi_Point_Precompute m_gy_mul;
       secure_vector<uint8_t> m_digest;
       std::vector<uint8_t> m_za;
       std::unique_ptr<HashFunction> m_hash;
@@ -239,7 +239,7 @@ bool SM2_Verification_Operation::is_valid_signature(const uint8_t sig[], size_t
    if(t == 0)
       return false;
 
-   const PointGFp R = m_gy_mul.multi_exp(s, t);
+   const EC_Point R = m_gy_mul.multi_exp(s, t);
 
    // ???
    if(R.is_zero())
diff --git a/src/lib/pubkey/sm2/sm2.h b/src/lib/pubkey/sm2/sm2.h
index d2edf3d6f..937f675e2 100644
--- a/src/lib/pubkey/sm2/sm2.h
+++ b/src/lib/pubkey/sm2/sm2.h
@@ -25,7 +25,7 @@ class BOTAN_PUBLIC_API(2,2) SM2_PublicKey : public virtual EC_PublicKey
       * @param public_point the public point defining this key
       */
       SM2_PublicKey(const EC_Group& dom_par,
-                    const PointGFp& public_point) :
+                    const EC_Point& public_point) :
          EC_PublicKey(dom_par, public_point) {}
 
       /**
@@ -112,7 +112,7 @@ std::vector<uint8_t>
 BOTAN_PUBLIC_API(2,5) sm2_compute_za(HashFunction& hash,
                                      const std::string& user_id,
                                      const EC_Group& domain,
-                                     const PointGFp& pubkey);
+                                     const EC_Point& pubkey);
 
 // For compat with versions 2.2 - 2.7
 typedef SM2_PublicKey SM2_Signature_PublicKey;
diff --git a/src/lib/pubkey/sm2/sm2_enc.cpp b/src/lib/pubkey/sm2/sm2_enc.cpp
index 0a40b6a0a..515f741a7 100644
--- a/src/lib/pubkey/sm2/sm2_enc.cpp
+++ b/src/lib/pubkey/sm2/sm2_enc.cpp
@@ -25,7 +25,7 @@ class SM2_Encryption_Operation final : public PK_Ops::Encryption
                                const std::string& kdf_hash) :
          m_group(key.domain()),
          m_kdf_hash(kdf_hash),
-         m_ws(PointGFp::WORKSPACE_SIZE),
+         m_ws(EC_Point::WORKSPACE_SIZE),
          m_mul_public_point(key.public_point(), rng, m_ws)
          {
          std::unique_ptr<HashFunction> hash = HashFunction::create_or_throw(m_kdf_hash);
@@ -57,7 +57,7 @@ class SM2_Encryption_Operation final : public PK_Ops::Encryption
 
          const BigInt k = m_group.random_scalar(rng);
 
-         const PointGFp C1 = m_group.blinded_base_point_multiply(k, rng, m_ws);
+         const EC_Point C1 = m_group.blinded_base_point_multiply(k, rng, m_ws);
          const BigInt x1 = C1.get_affine_x();
          const BigInt y1 = C1.get_affine_y();
          std::vector<uint8_t> x1_bytes(p_bytes);
@@ -65,7 +65,7 @@ class SM2_Encryption_Operation final : public PK_Ops::Encryption
          BigInt::encode_1363(x1_bytes.data(), x1_bytes.size(), x1);
          BigInt::encode_1363(y1_bytes.data(), y1_bytes.size(), y1);
 
-         const PointGFp kPB = m_mul_public_point.mul(k, rng, m_group.get_order(), m_ws);
+         const EC_Point kPB = m_mul_public_point.mul(k, rng, m_group.get_order(), m_ws);
 
          const BigInt x2 = kPB.get_affine_x();
          const BigInt y2 = kPB.get_affine_y();
@@ -105,7 +105,7 @@ class SM2_Encryption_Operation final : public PK_Ops::Encryption
       const std::string m_kdf_hash;
 
       std::vector<BigInt> m_ws;
-      PointGFp_Var_Point_Precompute m_mul_public_point;
+      EC_Point_Var_Point_Precompute m_mul_public_point;
       size_t m_hash_size;
    };
 
@@ -183,7 +183,7 @@ class SM2_Decryption_Operation final : public PK_Ops::Decryption
          if(same_mem(recode_ctext.data(), ciphertext, ciphertext_len) == false)
             return secure_vector<uint8_t>();
 
-         PointGFp C1 = group.point(x1, y1);
+         EC_Point C1 = group.point(x1, y1);
          C1.randomize_repr(m_rng);
 
          // Here C1 is publically invalid, so no problem with early return:
@@ -195,7 +195,7 @@ class SM2_Decryption_Operation final : public PK_Ops::Decryption
             return secure_vector<uint8_t>();
             }
 
-         const PointGFp dbC1 = group.blinded_var_point_multiply(
+         const EC_Point dbC1 = group.blinded_var_point_multiply(
             C1, m_key.private_value(), m_rng, m_ws);
 
          const BigInt x2 = dbC1.get_affine_x();
diff --git a/src/lib/tls/tls12/msg_server_kex.cpp b/src/lib/tls/tls12/msg_server_kex.cpp
index 92fc661c7..d7c1a52f8 100644
--- a/src/lib/tls/tls12/msg_server_kex.cpp
+++ b/src/lib/tls/tls12/msg_server_kex.cpp
@@ -115,7 +115,7 @@ Server_Key_Exchange::Server_Key_Exchange(Handshake_IO& io,
          // follow client's preference for point compression
          ecdh_public_val = ecdh->public_value(
             state.client_hello()->prefers_compressed_ec_points() ?
-            PointGFp::COMPRESSED : PointGFp::UNCOMPRESSED);
+            EC_Point::COMPRESSED : EC_Point::UNCOMPRESSED);
 
          m_kex_key.reset(ecdh.release());
          }
diff --git a/src/lib/tls/tls13/tls_extensions_key_share.cpp b/src/lib/tls/tls13/tls_extensions_key_share.cpp
index 9990e13c8..d19deaef0 100644
--- a/src/lib/tls/tls13/tls_extensions_key_share.cpp
+++ b/src/lib/tls/tls13/tls_extensions_key_share.cpp
@@ -82,7 +82,7 @@ class Key_Share_Entry
             //
             // Hence, we neither need to take Policy::use_ecc_point_compression() nor
             // ClientHello::prefers_compressed_ec_points() into account here.
-            m_key_exchange = skey->public_value(PointGFp::UNCOMPRESSED);
+            m_key_exchange = skey->public_value(EC_Point::UNCOMPRESSED);
             m_private_key = std::move(skey);
             }
          else if(is_dh(group))
diff --git a/src/lib/tls/tls_callbacks.cpp b/src/lib/tls/tls_callbacks.cpp
index f6d08d1a7..bef32cc75 100644
--- a/src/lib/tls/tls_callbacks.cpp
+++ b/src/lib/tls/tls_callbacks.cpp
@@ -223,7 +223,7 @@ std::pair<secure_vector<uint8_t>, std::vector<uint8_t>> TLS::Callbacks::tls_ecdh
       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);
+      our_public_value = priv_key.public_value(compressed ? EC_Point::COMPRESSED : EC_Point::UNCOMPRESSED);
       }
 
    return std::make_pair(ecdh_secret, our_public_value);


Test patch:
diff --git a/src/cli/timing_tests.cpp b/src/cli/timing_tests.cpp
index 8c8c6e6ed..1125a6743 100644
--- a/src/cli/timing_tests.cpp
+++ b/src/cli/timing_tests.cpp
@@ -337,7 +337,7 @@ ticks ECC_Mul_Timing_Test::measure_critical_function(const std::vector<uint8_t>&
 
    ticks start = get_ticks();
 
-   const Botan::PointGFp k_times_P = m_group.blinded_base_point_multiply(k, timing_test_rng(), m_ws);
+   const Botan::EC_Point k_times_P = m_group.blinded_base_point_multiply(k, timing_test_rng(), m_ws);
 
    ticks end = get_ticks();
 
diff --git a/src/tests/test_ec_group.cpp b/src/tests/test_ec_group.cpp
index 4b01d058c..f1c5a51e9 100644
--- a/src/tests/test_ec_group.cpp
+++ b/src/tests/test_ec_group.cpp
@@ -13,7 +13,7 @@
   #include <botan/numthry.h>
   #include <botan/internal/curve_nistp.h>
   #include <botan/pk_keys.h>
-  #include <botan/point_gfp.h>
+  #include <botan/ec_point.h>
   #include <botan/ec_group.h>
   #include <botan/reducer.h>
   #include <botan/hex.h>
@@ -80,7 +80,7 @@ Botan::BigInt test_integer(Botan::RandomNumberGenerator& rng, size_t bits, const
    return x;
    }
 
-Botan::PointGFp create_random_point(Botan::RandomNumberGenerator& rng,
+Botan::EC_Point create_random_point(Botan::RandomNumberGenerator& rng,
                                     const Botan::EC_Group& group)
    {
    const Botan::BigInt& p = group.get_p();
@@ -119,7 +119,7 @@ std::vector<Test::Result> ECC_Randomized_Tests::run()
 
       Botan::EC_Group group(group_name);
 
-      const Botan::PointGFp pt = create_random_point(Test::rng(), group);
+      const Botan::EC_Point pt = create_random_point(Test::rng(), group);
       const Botan::BigInt& group_order = group.get_order();
 
       std::vector<Botan::BigInt> blind_ws;
@@ -133,16 +133,16 @@ std::vector<Test::Result> ECC_Randomized_Tests::run()
             const Botan::BigInt b = Botan::BigInt::random_integer(Test::rng(), 2, group_order);
             const Botan::BigInt c = a + b;
 
-            const Botan::PointGFp P = pt * a;
-            const Botan::PointGFp Q = pt * b;
-            const Botan::PointGFp R = pt * c;
+            const Botan::EC_Point P = pt * a;
+            const Botan::EC_Point Q = pt * b;
+            const Botan::EC_Point R = pt * c;
 
-            Botan::PointGFp P1 = group.blinded_var_point_multiply(pt, a, Test::rng(), blind_ws);
-            Botan::PointGFp Q1 = group.blinded_var_point_multiply(pt, b, Test::rng(), blind_ws);
-            Botan::PointGFp R1 = group.blinded_var_point_multiply(pt, c, Test::rng(), blind_ws);
+            Botan::EC_Point P1 = group.blinded_var_point_multiply(pt, a, Test::rng(), blind_ws);
+            Botan::EC_Point Q1 = group.blinded_var_point_multiply(pt, b, Test::rng(), blind_ws);
+            Botan::EC_Point R1 = group.blinded_var_point_multiply(pt, c, Test::rng(), blind_ws);
 
-            Botan::PointGFp A1 = P + Q;
-            Botan::PointGFp A2 = Q + P;
+            Botan::EC_Point A1 = P + Q;
+            Botan::EC_Point A2 = Q + P;
 
             result.test_eq("p + q", A1, R);
             result.test_eq("q + p", A2, R);
@@ -310,10 +310,10 @@ class EC_Group_Tests : public Test
                result.test_ne("Group " + group_name + " A does not equal zero", group.get_a(), BigInt(0));
 
             // get a valid point
-            Botan::PointGFp p = group.get_base_point() * Test::rng().next_nonzero_byte();
+            Botan::EC_Point p = group.get_base_point() * Test::rng().next_nonzero_byte();
 
             // get a copy
-            Botan::PointGFp q = p;
+            Botan::EC_Point q = p;
 
             p.randomize_repr(Test::rng());
             q.randomize_repr(Test::rng());
@@ -341,12 +341,12 @@ class EC_Group_Tests : public Test
       static void test_ser_der(Test::Result& result, const Botan::EC_Group& group)
          {
          // generate point
-         const Botan::PointGFp pt = create_random_point(Test::rng(), group);
-         const Botan::PointGFp zero = group.zero_point();
+         const Botan::EC_Point pt = create_random_point(Test::rng(), group);
+         const Botan::EC_Point zero = group.zero_point();
 
-         for(auto scheme : { Botan::PointGFp::UNCOMPRESSED,
-                  Botan::PointGFp::COMPRESSED,
-                  Botan::PointGFp::HYBRID })
+         for(auto scheme : { Botan::EC_Point::UNCOMPRESSED,
+                  Botan::EC_Point::COMPRESSED,
+                  Botan::EC_Point::HYBRID })
             {
             result.test_eq("encoded/decode rt works", group.OS2ECP(pt.encode(scheme)), pt);
             result.test_eq("encoded/decode rt works", group.OS2ECP(zero.encode(scheme)), zero);
@@ -355,9 +355,9 @@ class EC_Group_Tests : public Test
 
       static void test_basic_math(Test::Result& result, const Botan::EC_Group& group)
          {
-         const Botan::PointGFp& G = group.get_base_point();
+         const Botan::EC_Point& G = group.get_base_point();
 
-         Botan::PointGFp p1 = G * 2;
+         Botan::EC_Point p1 = G * 2;
          p1 += G;
 
          result.test_eq("point addition", p1, G * 3);
@@ -367,18 +367,18 @@ class EC_Group_Tests : public Test
          result.test_eq("point subtraction", p1, G);
 
          // The scalar multiplication algorithm relies on this being true:
-         Botan::PointGFp zero_coords = group.point(0, 0);
+         Botan::EC_Point zero_coords = group.point(0, 0);
          result.confirm("point (0,0) is not on the curve", !zero_coords.on_the_curve());
          }
 
       static void test_point_swap(Test::Result& result, const Botan::EC_Group& group)
          {
-         Botan::PointGFp a(create_random_point(Test::rng(), group));
-         Botan::PointGFp b(create_random_point(Test::rng(), group));
+         Botan::EC_Point a(create_random_point(Test::rng(), group));
+         Botan::EC_Point b(create_random_point(Test::rng(), group));
          b *= Botan::BigInt(Test::rng(), 20);
 
-         Botan::PointGFp c(a);
-         Botan::PointGFp d(b);
+         Botan::EC_Point c(a);
+         Botan::EC_Point d(b);
 
          d.swap(c);
          result.test_eq("swap correct", a, d);
@@ -387,26 +387,26 @@ class EC_Group_Tests : public Test
 
       static void test_zeropoint(Test::Result& result, const Botan::EC_Group& group)
          {
-         Botan::PointGFp zero = group.zero_point();
+         Botan::EC_Point zero = group.zero_point();
 
          result.test_throws("Zero point throws", "Cannot convert zero point to affine",
                             [&]() { zero.get_affine_x(); });
          result.test_throws("Zero point throws", "Cannot convert zero point to affine",
                             [&]() { zero.get_affine_y(); });
 
-         const Botan::PointGFp p1 = group.get_base_point() * 2;
+         const Botan::EC_Point p1 = group.get_base_point() * 2;
 
          result.confirm("point is on the curve", p1.on_the_curve());
          result.confirm("point is not zero", !p1.is_zero());
 
-         Botan::PointGFp p2 = p1;
+         Botan::EC_Point p2 = p1;
          p2 -= p1;
 
          result.confirm("p - q with q = p results in zero", p2.is_zero());
 
-         const Botan::PointGFp minus_p1 = -p1;
+         const Botan::EC_Point minus_p1 = -p1;
          result.confirm("point is on the curve", minus_p1.on_the_curve());
-         const Botan::PointGFp shouldBeZero = p1 + minus_p1;
+         const Botan::EC_Point shouldBeZero = p1 + minus_p1;
          result.confirm("point is on the curve", shouldBeZero.on_the_curve());
          result.confirm("point is zero", shouldBeZero.is_zero());
 
@@ -420,9 +420,9 @@ class EC_Group_Tests : public Test
          result.test_eq("addition of zero does nothing", p1, p1 - zero);
          result.confirm("zero times anything is the zero point", (zero * 39193).is_zero());
 
-         for(auto scheme : { Botan::PointGFp::UNCOMPRESSED,
-                  Botan::PointGFp::COMPRESSED,
-                  Botan::PointGFp::HYBRID })
+         for(auto scheme : { Botan::EC_Point::UNCOMPRESSED,
+                  Botan::EC_Point::COMPRESSED,
+                  Botan::EC_Point::HYBRID })
             {
             const std::vector<uint8_t> v = zero.encode(scheme);
             result.test_eq("encoded/decode rt works", group.OS2ECP(v), zero);
@@ -459,12 +459,12 @@ Test::Result test_coordinates()
 
    // precalculation
    const Botan::EC_Group secp160r1("secp160r1");
-   const Botan::PointGFp& p_G = secp160r1.get_base_point();
+   const Botan::EC_Point& p_G = secp160r1.get_base_point();
 
-   const Botan::PointGFp point_exp = secp160r1.point(exp_affine_x, exp_affine_y);
+   const Botan::EC_Point point_exp = secp160r1.point(exp_affine_x, exp_affine_y);
    result.confirm("Point is on the curve", point_exp.on_the_curve());
 
-   const Botan::PointGFp p1 = p_G * 2;
+   const Botan::EC_Point p1 = p_G * 2;
    result.test_eq("Point affine x", p1.get_affine_x(), exp_affine_x);
    result.test_eq("Point affine y", p1.get_affine_y(), exp_affine_y);
    return result;
@@ -487,10 +487,10 @@ Test::Result test_point_mult()
    Test::Result result("ECC Unit");
 
    Botan::EC_Group secp160r1("secp160r1");
-   const Botan::PointGFp& p_G = secp160r1.get_base_point();
+   const Botan::EC_Point& p_G = secp160r1.get_base_point();
 
    Botan::BigInt d_U("0xaa374ffc3ce144e6b073307972cb6d57b2a4e982");
-   Botan::PointGFp Q_U = d_U * p_G;
+   Botan::EC_Point Q_U = d_U * p_G;
 
    result.test_eq("affine x", Q_U.get_affine_x(), Botan::BigInt("466448783855397898016055842232266600516272889280"));
    result.test_eq("affine y", Q_U.get_affine_y(), Botan::BigInt("1110706324081757720403272427311003102474457754220"));
@@ -502,14 +502,14 @@ Test::Result test_point_negative()
    Test::Result result("ECC Unit");
 
    Botan::EC_Group secp160r1("secp160r1");
-   const Botan::PointGFp& p_G = secp160r1.get_base_point();
+   const Botan::EC_Point& p_G = secp160r1.get_base_point();
 
-   const Botan::PointGFp p1 = p_G * 2;
+   const Botan::EC_Point p1 = p_G * 2;
 
    result.test_eq("affine x", p1.get_affine_x(), Botan::BigInt("16984103820118642236896513183038186009872590470"));
    result.test_eq("affine y", p1.get_affine_y(), Botan::BigInt("1373093393927139016463695321221277758035357890939"));
 
-   const Botan::PointGFp p1_neg = -p1;
+   const Botan::EC_Point p1_neg = -p1;
 
    result.test_eq("affine x", p1_neg.get_affine_x(), p1.get_affine_x());
    result.test_eq("affine y", p1_neg.get_affine_y(),  Botan::BigInt("88408243403763901739989511495005261618427168388"));
@@ -521,16 +521,16 @@ Test::Result test_mult_point()
    Test::Result result("ECC Unit");
 
    Botan::EC_Group secp160r1("secp160r1");
-   const Botan::PointGFp& p_G = secp160r1.get_base_point();
+   const Botan::EC_Point& p_G = secp160r1.get_base_point();
 
-   const Botan::PointGFp& p0 = p_G;
-   Botan::PointGFp p1 = p_G * 2;
+   const Botan::EC_Point& p0 = p_G;
+   Botan::EC_Point p1 = p_G * 2;
 
    p1 *= p0.get_affine_x();
 
    const Botan::BigInt exp_mult_x(std::string("967697346845926834906555988570157345422864716250"));
    const Botan::BigInt exp_mult_y(std::string("512319768365374654866290830075237814703869061656"));
-   Botan::PointGFp expected = secp160r1.point(exp_mult_x, exp_mult_y);
+   Botan::EC_Point expected = secp160r1.point(exp_mult_x, exp_mult_y);
 
    result.test_eq("point mult", p1, expected);
    return result;
@@ -543,11 +543,11 @@ Test::Result test_mixed_points()
    Botan::EC_Group secp256r1("secp256r1");
    Botan::EC_Group secp384r1("secp384r1");
 
-   const Botan::PointGFp& G256 = secp256r1.get_base_point();
-   const Botan::PointGFp& G384 = secp384r1.get_base_point();
+   const Botan::EC_Point& G256 = secp256r1.get_base_point();
+   const Botan::EC_Point& G384 = secp384r1.get_base_point();
 
    result.test_throws("Mixing points from different groups",
-                      [&] { Botan::PointGFp p = G256 + G384; });
+                      [&] { Botan::EC_Point p = G256 + G384; });
    return result;
    }
 
@@ -557,24 +557,24 @@ Test::Result test_basic_operations()
 
    // precalculation
    Botan::EC_Group secp160r1("secp160r1");
-   const Botan::PointGFp& p_G = secp160r1.get_base_point();
+   const Botan::EC_Point& p_G = secp160r1.get_base_point();
 
-   const Botan::PointGFp& p0 = p_G;
-   const Botan::PointGFp p1 = p_G * 2;
+   const Botan::EC_Point& p0 = p_G;
+   const Botan::EC_Point p1 = p_G * 2;
 
    result.test_eq("p1 affine x", p1.get_affine_x(), Botan::BigInt("16984103820118642236896513183038186009872590470"));
    result.test_eq("p1 affine y", p1.get_affine_y(), Botan::BigInt("1373093393927139016463695321221277758035357890939"));
 
-   const Botan::PointGFp simplePlus = p1 + p0;
-   const Botan::PointGFp exp_simplePlus = secp160r1.point(Botan::BigInt("704859595002530890444080436569091156047721708633"),
+   const Botan::EC_Point simplePlus = p1 + p0;
+   const Botan::EC_Point exp_simplePlus = secp160r1.point(Botan::BigInt("704859595002530890444080436569091156047721708633"),
                                                           Botan::BigInt("1147993098458695153857594941635310323215433166682"));
 
    result.test_eq("point addition", simplePlus, exp_simplePlus);
 
-   const Botan::PointGFp simpleMinus = p1 - p0;
+   const Botan::EC_Point simpleMinus = p1 - p0;
    result.test_eq("point subtraction", simpleMinus, p_G);
 
-   const Botan::PointGFp simpleMult = p1 * 123456789;
+   const Botan::EC_Point simpleMult = p1 * 123456789;
 
    result.test_eq("point mult affine x", simpleMult.get_affine_x(),
                   Botan::BigInt("43638877777452195295055270548491599621118743290"));
@@ -591,8 +591,8 @@ Test::Result test_enc_dec_compressed_160()
    // Test for compressed conversion (02/03) 160bit
    Botan::EC_Group secp160r1("secp160r1");
    const std::vector<uint8_t> G_comp = Botan::hex_decode("024A96B5688EF573284664698968C38BB913CBFC82");
-   const Botan::PointGFp p = secp160r1.OS2ECP(G_comp);
-   const std::vector<uint8_t> sv_result = p.encode(Botan::PointGFp::COMPRESSED);
+   const Botan::EC_Point p = secp160r1.OS2ECP(G_comp);
+   const std::vector<uint8_t> sv_result = p.encode(Botan::EC_Point::COMPRESSED);
 
    result.test_eq("result", sv_result, G_comp);
    return result;
@@ -607,8 +607,8 @@ Test::Result test_enc_dec_compressed_256()
    const std::string G_secp_comp = "036B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296";
    const std::vector<uint8_t> sv_G_secp_comp = Botan::hex_decode(G_secp_comp);
 
-   Botan::PointGFp p_G = group.OS2ECP(sv_G_secp_comp);
-   std::vector<uint8_t> sv_result = p_G.encode(Botan::PointGFp::COMPRESSED);
+   Botan::EC_Point p_G = group.OS2ECP(sv_G_secp_comp);
+   std::vector<uint8_t> sv_result = p_G.encode(Botan::EC_Point::COMPRESSED);
 
    result.test_eq("compressed_256", sv_result, sv_G_secp_comp);
    return result;
@@ -638,8 +638,8 @@ Test::Result test_enc_dec_uncompressed_112()
    const std::string G_secp_uncomp = "044BA30AB5E892B4E1649DD0928643ADCD46F5882E3747DEF36E956E97";
    const std::vector<uint8_t> sv_G_secp_uncomp = Botan::hex_decode(G_secp_uncomp);
 
-   Botan::PointGFp p_G = group.OS2ECP(sv_G_secp_uncomp);
-   std::vector<uint8_t> sv_result = p_G.encode(Botan::PointGFp::UNCOMPRESSED);
+   Botan::EC_Point p_G = group.OS2ECP(sv_G_secp_uncomp);
+   std::vector<uint8_t> sv_result = p_G.encode(Botan::EC_Point::UNCOMPRESSED);
 
    result.test_eq("uncompressed_112", sv_result, sv_G_secp_uncomp);
    return result;
@@ -658,9 +658,9 @@ Test::Result test_enc_dec_uncompressed_521()
 
    Botan::EC_Group group("secp521r1");
 
-   Botan::PointGFp p_G = group.OS2ECP(sv_G_secp_uncomp);
+   Botan::EC_Point p_G = group.OS2ECP(sv_G_secp_uncomp);
 
-   std::vector<uint8_t> sv_result = p_G.encode(Botan::PointGFp::UNCOMPRESSED);
+   std::vector<uint8_t> sv_result = p_G.encode(Botan::EC_Point::UNCOMPRESSED);
 
    result.test_eq("expected", sv_result, sv_G_secp_uncomp);
    return result;
diff --git a/src/tests/test_ecc_pointmul.cpp b/src/tests/test_ecc_pointmul.cpp
index ede4a80fa..1f297188c 100644
--- a/src/tests/test_ecc_pointmul.cpp
+++ b/src/tests/test_ecc_pointmul.cpp
@@ -35,18 +35,18 @@ class ECC_Basepoint_Mul_Tests final : public Text_Based_Test
 
          Botan::EC_Group group(Botan::OID::from_string(group_id));
 
-         const Botan::PointGFp& base_point = group.get_base_point();
+         const Botan::EC_Point& base_point = group.get_base_point();
 
-         const Botan::PointGFp p1 = base_point * m;
+         const Botan::EC_Point p1 = base_point * m;
          result.test_eq("p1 affine X", p1.get_affine_x(), X);
          result.test_eq("p1 affine Y", p1.get_affine_y(), Y);
 
          std::vector<Botan::BigInt> ws;
-         const Botan::PointGFp p2 = group.blinded_base_point_multiply(m, Test::rng(), ws);
+         const Botan::EC_Point p2 = group.blinded_base_point_multiply(m, Test::rng(), ws);
          result.test_eq("p2 affine X", p2.get_affine_x(), X);
          result.test_eq("p2 affine Y", p2.get_affine_y(), Y);
 
-         const Botan::PointGFp p3 = group.blinded_var_point_multiply(base_point, m, Test::rng(), ws);
+         const Botan::EC_Point p3 = group.blinded_var_point_multiply(base_point, m, Test::rng(), ws);
          result.test_eq("p3 affine X", p3.get_affine_x(), X);
          result.test_eq("p3 affine Y", p3.get_affine_y(), Y);
 
@@ -73,18 +73,18 @@ class ECC_Varpoint_Mul_Tests final : public Text_Based_Test
 
          Botan::EC_Group group(Botan::OID::from_string(group_id));
 
-         const Botan::PointGFp pt = group.point(X, Y);
+         const Botan::EC_Point pt = group.point(X, Y);
 
          result.confirm("Input point is on the curve", pt.on_the_curve());
 
-         const Botan::PointGFp p1 = pt * k;
+         const Botan::EC_Point p1 = pt * k;
          result.test_eq("p1 affine X", p1.get_affine_x(), kX);
          result.test_eq("p1 affine Y", p1.get_affine_y(), kY);
 
          result.confirm("Output point is on the curve", p1.on_the_curve());
 
          std::vector<Botan::BigInt> ws;
-         const Botan::PointGFp p2 = group.blinded_var_point_multiply(pt, k, Test::rng(), ws);
+         const Botan::EC_Point p2 = group.blinded_var_point_multiply(pt, k, Test::rng(), ws);
          result.test_eq("p2 affine X", p2.get_affine_x(), kX);
          result.test_eq("p2 affine Y", p2.get_affine_y(), kY);
 
diff --git a/src/tests/test_ecdsa.cpp b/src/tests/test_ecdsa.cpp
index 42f0a01dc..260dc35d1 100644
--- a/src/tests/test_ecdsa.cpp
+++ b/src/tests/test_ecdsa.cpp
@@ -42,7 +42,7 @@ class ECDSA_Verification_Tests final : public PK_Signature_Verification_Test
          const BigInt py = vars.get_req_bn("Py");
          Botan::EC_Group group(Botan::OID::from_string(group_id));
 
-         const Botan::PointGFp public_point = group.point(px, py);
+         const Botan::EC_Point public_point = group.point(px, py);
 
          return std::make_unique<Botan::ECDSA_PublicKey>(group, public_point);
          }
@@ -81,7 +81,7 @@ class ECDSA_Wycheproof_Verification_Tests final : public PK_Signature_Verificati
          const BigInt py = vars.get_req_bn("Py");
          Botan::EC_Group group(Botan::OID::from_string(group_id));
 
-         const Botan::PointGFp public_point = group.point(px, py);
+         const Botan::EC_Point public_point = group.point(px, py);
 
          return std::make_unique<Botan::ECDSA_PublicKey>(group, public_point);
          }
@@ -232,15 +232,15 @@ class ECDSA_Invalid_Key_Tests final : public Text_Based_Test
          const Botan::BigInt x = vars.get_req_bn("InvalidKeyX");
          const Botan::BigInt y = vars.get_req_bn("InvalidKeyY");
 
-         std::unique_ptr<Botan::PointGFp> public_point;
+         std::unique_ptr<Botan::EC_Point> public_point;
 
          try
             {
-            public_point.reset(new Botan::PointGFp(group.point(x, y)));
+            public_point.reset(new Botan::EC_Point(group.point(x, y)));
             }
          catch(Botan::Invalid_Argument&)
             {
-            // PointGFp() performs a range check on x, y in [0, p−1],
+            // EC_Point() performs a range check on x, y in [0, p−1],
             // which is also part of the EC public key checks, e.g.,
             // in NIST SP800-56A rev2, sec. 5.6.2.3.2
             result.test_success("public key fails check");
diff --git a/src/tests/test_ecies.cpp b/src/tests/test_ecies.cpp
index 3a89b0550..3f3dacba0 100644
--- a/src/tests/test_ecies.cpp
+++ b/src/tests/test_ecies.cpp
@@ -20,19 +20,19 @@ namespace {
 
 using Flags = Botan::ECIES_Flags;
 
-Botan::PointGFp::Compression_Type get_compression_type(const std::string& format)
+Botan::EC_Point::Compression_Type get_compression_type(const std::string& format)
    {
    if(format == "uncompressed")
       {
-      return Botan::PointGFp::UNCOMPRESSED;
+      return Botan::EC_Point::UNCOMPRESSED;
       }
    else if(format == "compressed")
       {
-      return Botan::PointGFp::COMPRESSED;
+      return Botan::EC_Point::COMPRESSED;
       }
    else if(format == "hybrid")
       {
-      return Botan::PointGFp::HYBRID;
+      return Botan::EC_Point::HYBRID;
       }
    throw Botan::Invalid_Argument("invalid compression format");
    }
@@ -112,7 +112,7 @@ class ECIES_ISO_Tests final : public Text_Based_Test
          Test::Result result("ECIES-ISO");
 
          // get test vectors defined by ISO 18033
-         const Botan::PointGFp::Compression_Type compression_type = get_compression_type(vars.get_req_str("format"));
+         const Botan::EC_Point::Compression_Type compression_type = get_compression_type(vars.get_req_str("format"));
          const Botan::BigInt p = vars.get_req_bn("p");
          const Botan::BigInt a = vars.get_req_bn("a");
          const Botan::BigInt b = vars.get_req_bn("b");
@@ -131,12 +131,12 @@ class ECIES_ISO_Tests final : public Text_Based_Test
 
          // keys of bob
          const Botan::ECDH_PrivateKey other_private_key(Test::rng(), domain, x);
-         const Botan::PointGFp other_public_key_point = domain.point(hx, hy);
+         const Botan::EC_Point other_public_key_point = domain.point(hx, hy);
          const Botan::ECDH_PublicKey other_public_key(domain, other_public_key_point);
 
          // (ephemeral) keys of alice
          const Botan::ECDH_PrivateKey eph_private_key(Test::rng(), domain, r);
-         const Botan::PointGFp eph_public_key_point = eph_private_key.public_point();
+         const Botan::EC_Point eph_public_key_point = eph_private_key.public_point();
          const std::vector<uint8_t> eph_public_key_bin = eph_public_key_point.encode(compression_type);
          result.test_eq("encoded (ephemeral) public key", eph_public_key_bin, c0);
 
@@ -149,7 +149,7 @@ class ECIES_ISO_Tests final : public Text_Based_Test
 
          // test encryption / decryption
 
-         for(auto comp_type : { Botan::PointGFp::UNCOMPRESSED, Botan::PointGFp::COMPRESSED, Botan::PointGFp::HYBRID })
+         for(auto comp_type : { Botan::EC_Point::UNCOMPRESSED, Botan::EC_Point::COMPRESSED, Botan::EC_Point::HYBRID })
             {
             for(bool cofactor_mode : { true, false })
                {
@@ -213,7 +213,7 @@ class ECIES_Tests final : public Text_Based_Test
          const std::vector<uint8_t> iv = vars.get_opt_bin("Iv");
          const std::string mac = vars.get_req_str("Mac");
          const size_t mac_key_len = vars.get_req_sz("MacKeyLen");
-         const Botan::PointGFp::Compression_Type compression_type = get_compression_type(vars.get_req_str("Format"));
+         const Botan::EC_Point::Compression_Type compression_type = get_compression_type(vars.get_req_str("Format"));
          const bool cofactor_mode = vars.get_req_sz("CofactorMode") != 0;
          const bool old_cofactor_mode = vars.get_req_sz("OldCofactorMode") != 0;
          const bool check_mode = vars.get_req_sz("CheckMode") != 0;
@@ -252,7 +252,7 @@ Test::Result test_other_key_not_set()
 
    const Botan::ECDH_PrivateKey private_key(Test::rng(), domain, private_key_value);
    const Botan::ECIES_System_Params ecies_params(private_key.domain(), "KDF1-18033(SHA-512)", "AES-256/CBC", 32,
-         "HMAC(SHA-512)", 20, Botan::PointGFp::Compression_Type::COMPRESSED,
+         "HMAC(SHA-512)", 20, Botan::EC_Point::Compression_Type::COMPRESSED,
          flags);
 
    Botan::ECIES_Encryptor ecies_enc(private_key, ecies_params, Test::rng());
@@ -277,7 +277,7 @@ Test::Result test_kdf_not_found()
 
    const Botan::ECDH_PrivateKey private_key(Test::rng(), domain, private_key_value);
    const Botan::ECIES_System_Params ecies_params(private_key.domain(), "KDF-XYZ(SHA-512)", "AES-256/CBC", 32,
-         "HMAC(SHA-512)", 20, Botan::PointGFp::Compression_Type::COMPRESSED,
+         "HMAC(SHA-512)", 20, Botan::EC_Point::Compression_Type::COMPRESSED,
          flags);
 
    result.test_throws("kdf not found", [&]()
@@ -301,7 +301,7 @@ Test::Result test_mac_not_found()
 
    const Botan::ECDH_PrivateKey private_key(Test::rng(), domain, private_key_value);
    const Botan::ECIES_System_Params ecies_params(private_key.domain(), "KDF1-18033(SHA-512)", "AES-256/CBC", 32,
-         "XYZMAC(SHA-512)", 20, Botan::PointGFp::Compression_Type::COMPRESSED,
+         "XYZMAC(SHA-512)", 20, Botan::EC_Point::Compression_Type::COMPRESSED,
          flags);
 
    result.test_throws("mac not found", [&]()
@@ -325,7 +325,7 @@ Test::Result test_cipher_not_found()
 
    const Botan::ECDH_PrivateKey private_key(Test::rng(), domain, private_key_value);
    const Botan::ECIES_System_Params ecies_params(private_key.domain(), "KDF1-18033(SHA-512)", "AES-XYZ-256/CBC", 32,
-         "HMAC(SHA-512)", 20, Botan::PointGFp::Compression_Type::COMPRESSED,
+         "HMAC(SHA-512)", 20, Botan::EC_Point::Compression_Type::COMPRESSED,
          flags);
 
    result.test_throws("cipher not found", [&]()
diff --git a/src/tests/test_gost_3410.cpp b/src/tests/test_gost_3410.cpp
index 5fd2726c1..f9d46699a 100644
--- a/src/tests/test_gost_3410.cpp
+++ b/src/tests/test_gost_3410.cpp
@@ -41,7 +41,7 @@ class GOST_3410_2001_Verification_Tests final : public PK_Signature_Verification
          const BigInt Px = vars.get_req_bn("Px");
          const BigInt Py = vars.get_req_bn("Py");
 
-         const Botan::PointGFp public_point = group.point(Px, Py);
+         const Botan::EC_Point public_point = group.point(Px, Py);
 
          return std::make_unique<Botan::GOST_3410_PublicKey>(group, public_point);
          }
diff --git a/src/tests/test_pkcs11_high_level.cpp b/src/tests/test_pkcs11_high_level.cpp
index 7b8d2d438..b82f3d3a1 100644
--- a/src/tests/test_pkcs11_high_level.cpp
+++ b/src/tests/test_pkcs11_high_level.cpp
@@ -947,10 +947,10 @@ BOTAN_REGISTER_TEST("pkcs11", "pkcs11-rsa", PKCS11_RSA_Tests);
 /***************************** PKCS11 ECDSA *****************************/
 
 #if defined(BOTAN_HAS_ECC_GROUP) && (defined(BOTAN_HAS_ECDSA) || defined(BOTAN_HAS_ECDH))
-std::vector<uint8_t> encode_ec_point_in_octet_str(const Botan::PointGFp& point)
+std::vector<uint8_t> encode_ec_point_in_octet_str(const Botan::EC_Point& point)
    {
    std::vector<uint8_t> enc;
-   DER_Encoder(enc).encode(point.encode(PointGFp::UNCOMPRESSED), ASN1_Type::OctetString);
+   DER_Encoder(enc).encode(point.encode(EC_Point::UNCOMPRESSED), ASN1_Type::OctetString);
    return enc;
    }
 #endif
@@ -1422,8 +1422,8 @@ Test::Result test_ecdh_derive()
    Botan::PK_Key_Agreement ka(keypair.second, Test::rng(), "Raw");
    Botan::PK_Key_Agreement kb(keypair2.second, Test::rng(), "Raw");
 
-   Botan::SymmetricKey alice_key = ka.derive_key(32, keypair2.first.public_point().encode(PointGFp::UNCOMPRESSED));
-   Botan::SymmetricKey bob_key = kb.derive_key(32, keypair.first.public_point().encode(PointGFp::UNCOMPRESSED));
+   Botan::SymmetricKey alice_key = ka.derive_key(32, keypair2.first.public_point().encode(EC_Point::UNCOMPRESSED));
+   Botan::SymmetricKey bob_key = kb.derive_key(32, keypair.first.public_point().encode(EC_Point::UNCOMPRESSED));
 
    bool eq = alice_key == bob_key;
    result.test_eq("same secret key derived", eq, true);
diff --git a/src/tests/tests.cpp b/src/tests/tests.cpp
index 4a6c5a634..342c9b8a6 100644
--- a/src/tests/tests.cpp
+++ b/src/tests/tests.cpp
@@ -20,7 +20,7 @@
 #endif
 
 #if defined(BOTAN_HAS_EC_CURVE_GFP)
-   #include <botan/point_gfp.h>
+   #include <botan/ec_point.h>
 #endif
 
 #if defined(BOTAN_TARGET_OS_HAS_POSIX1)
@@ -376,7 +376,7 @@ bool Test::Result::test_ne(const std::string& what, const BigInt& produced, cons
 
 #if defined(BOTAN_HAS_EC_CURVE_GFP)
 bool Test::Result::test_eq(const std::string& what,
-                           const Botan::PointGFp& a, const Botan::PointGFp& b)
+                           const Botan::EC_Point& a, const Botan::EC_Point& b)
    {
    //return test_is_eq(what, a, b);
    if(a == b)
diff --git a/src/tests/tests.h b/src/tests/tests.h
index 220bf0bbf..bca1def23 100644
--- a/src/tests/tests.h
+++ b/src/tests/tests.h
@@ -32,7 +32,7 @@ class BigInt;
 #endif
 
 #if defined(BOTAN_HAS_EC_CURVE_GFP)
-class PointGFp;
+class EC_Point;
 #endif
 
 }
@@ -469,8 +469,8 @@ class Test
 
 #if defined(BOTAN_HAS_EC_CURVE_GFP)
             bool test_eq(const std::string& what,
-                         const Botan::PointGFp& a,
-                         const Botan::PointGFp& b);
+                         const Botan::EC_Point& a,
+                         const Botan::EC_Point& b);
 #endif
 
             bool test_eq(const char* producer, const std::string& what,
diff --git a/src/tests/unit_ecdsa.cpp b/src/tests/unit_ecdsa.cpp
index 6769b115d..63c4f9926 100644
--- a/src/tests/unit_ecdsa.cpp
+++ b/src/tests/unit_ecdsa.cpp
@@ -253,7 +253,7 @@ Test::Result test_unusual_curve()
 
    Botan::EC_Group dom_params(p, a, b, Gx, Gy, order_g, cofactor);
 
-   Botan::PointGFp p_G = dom_params.point(Gx, Gy);
+   Botan::EC_Point p_G = dom_params.point(Gx, Gy);
 
    if(!result.confirm("G is on curve", p_G.on_the_curve()))
       {
@@ -279,14 +279,14 @@ Test::Result test_encoding_options()
    Botan::ECDSA_PrivateKey key(Test::rng(), group);
 
    result.confirm("Default encoding is uncompressed",
-                  key.point_encoding() == Botan::PointGFp::UNCOMPRESSED);
+                  key.point_encoding() == Botan::EC_Point::UNCOMPRESSED);
 
    const std::vector<uint8_t> enc_uncompressed = key.public_key_bits();
 
-   key.set_point_encoding(Botan::PointGFp::COMPRESSED);
+   key.set_point_encoding(Botan::EC_Point::COMPRESSED);
 
    result.confirm("set_point_encoding works",
-                  key.point_encoding() == Botan::PointGFp::COMPRESSED);
+                  key.point_encoding() == Botan::EC_Point::COMPRESSED);
 
    const std::vector<uint8_t> enc_compressed = key.public_key_bits();
 
@@ -298,10 +298,10 @@ Test::Result test_encoding_options()
    result.test_gte("Compressed points smaller by group size",
                    size_diff, 32);
 
-   key.set_point_encoding(Botan::PointGFp::HYBRID);
+   key.set_point_encoding(Botan::EC_Point::HYBRID);
 
    result.confirm("set_point_encoding works",
-                  key.point_encoding() == Botan::PointGFp::HYBRID);
+                  key.point_encoding() == Botan::EC_Point::HYBRID);
 
    const std::vector<uint8_t> enc_hybrid = key.public_key_bits();
 
@@ -309,7 +309,7 @@ Test::Result test_encoding_options()
                   enc_uncompressed.size(), enc_hybrid.size());
 
 #if !defined(BOTAN_HAS_SANITIZER_UNDEFINED)
-   auto invalid_format = static_cast<Botan::PointGFp::Compression_Type>(99);
+   auto invalid_format = static_cast<Botan::EC_Point::Compression_Type>(99);
 
    result.test_throws("Invalid point format throws",
                       "Invalid point encoding for EC_PublicKey",