<h2>Editing File: /opt/cpanel/ea-openssl11/share/doc/openssl/html/man3/EC_POINT_new.html</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?xml version=&quot;1.0&quot; ?&gt;
&lt;!DOCTYPE html PUBLIC &quot;-//W3C//DTD XHTML 1.0 Strict//EN&quot; &quot;http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd&quot;&gt;
&lt;html xmlns=&quot;http://www.w3.org/1999/xhtml&quot;&gt;
&lt;head&gt;
&lt;title&gt;EC_POINT_new&lt;/title&gt;
&lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=utf-8&quot; /&gt;
&lt;link rev=&quot;made&quot; href=&quot;mailto:root@localhost&quot; /&gt;
&lt;/head&gt;

&lt;body&gt;


&lt;ul id=&quot;index&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#NAME&quot;&gt;NAME&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#SYNOPSIS&quot;&gt;SYNOPSIS&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#DESCRIPTION&quot;&gt;DESCRIPTION&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#RETURN-VALUES&quot;&gt;RETURN VALUES&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#SEE-ALSO&quot;&gt;SEE ALSO&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#COPYRIGHT&quot;&gt;COPYRIGHT&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h1 id=&quot;NAME&quot;&gt;NAME&lt;/h1&gt;

&lt;p&gt;EC_POINT_set_Jprojective_coordinates_GFp, EC_POINT_point2buf, EC_POINT_new, EC_POINT_free, EC_POINT_clear_free, EC_POINT_copy, EC_POINT_dup, EC_POINT_method_of, EC_POINT_set_to_infinity, EC_POINT_get_Jprojective_coordinates_GFp, EC_POINT_set_affine_coordinates, EC_POINT_get_affine_coordinates, EC_POINT_set_compressed_coordinates, EC_POINT_set_affine_coordinates_GFp, EC_POINT_get_affine_coordinates_GFp, EC_POINT_set_compressed_coordinates_GFp, EC_POINT_set_affine_coordinates_GF2m, EC_POINT_get_affine_coordinates_GF2m, EC_POINT_set_compressed_coordinates_GF2m, EC_POINT_point2oct, EC_POINT_oct2point, EC_POINT_point2bn, EC_POINT_bn2point, EC_POINT_point2hex, EC_POINT_hex2point - Functions for creating, destroying and manipulating EC_POINT objects&lt;/p&gt;

&lt;h1 id=&quot;SYNOPSIS&quot;&gt;SYNOPSIS&lt;/h1&gt;

&lt;pre&gt;&lt;code&gt; #include &amp;lt;openssl/ec.h&amp;gt;

 EC_POINT *EC_POINT_new(const EC_GROUP *group);
 void EC_POINT_free(EC_POINT *point);
 void EC_POINT_clear_free(EC_POINT *point);
 int EC_POINT_copy(EC_POINT *dst, const EC_POINT *src);
 EC_POINT *EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group);
 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point);
 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point);
 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group,
                                              EC_POINT *p,
                                              const BIGNUM *x, const BIGNUM *y,
                                              const BIGNUM *z, BN_CTX *ctx);
 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group,
                                              const EC_POINT *p,
                                              BIGNUM *x, BIGNUM *y, BIGNUM *z,
                                              BN_CTX *ctx);
 int EC_POINT_set_affine_coordinates(const EC_GROUP *group, EC_POINT *p,
                                     const BIGNUM *x, const BIGNUM *y,
                                     BN_CTX *ctx);
 int EC_POINT_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *p,
                                     BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
 int EC_POINT_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *p,
                                         const BIGNUM *x, int y_bit,
                                         BN_CTX *ctx);
 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *p,
                                         const BIGNUM *x, const BIGNUM *y,
                                         BN_CTX *ctx);
 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group,
                                         const EC_POINT *p,
                                         BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group,
                                             EC_POINT *p,
                                             const BIGNUM *x, int y_bit,
                                             BN_CTX *ctx);
 int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP *group, EC_POINT *p,
                                          const BIGNUM *x, const BIGNUM *y,
                                          BN_CTX *ctx);
 int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP *group,
                                          const EC_POINT *p,
                                          BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
 int EC_POINT_set_compressed_coordinates_GF2m(const EC_GROUP *group,
                                              EC_POINT *p,
                                              const BIGNUM *x, int y_bit,
                                              BN_CTX *ctx);
 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *p,
                           point_conversion_form_t form,
                           unsigned char *buf, size_t len, BN_CTX *ctx);
 size_t EC_POINT_point2buf(const EC_GROUP *group, const EC_POINT *point,
                           point_conversion_form_t form,
                           unsigned char **pbuf, BN_CTX *ctx);
 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *p,
                        const unsigned char *buf, size_t len, BN_CTX *ctx);
 BIGNUM *EC_POINT_point2bn(const EC_GROUP *group, const EC_POINT *p,
                           point_conversion_form_t form, BIGNUM *bn,
                           BN_CTX *ctx);
 EC_POINT *EC_POINT_bn2point(const EC_GROUP *group, const BIGNUM *bn,
                             EC_POINT *p, BN_CTX *ctx);
 char *EC_POINT_point2hex(const EC_GROUP *group, const EC_POINT *p,
                          point_conversion_form_t form, BN_CTX *ctx);
 EC_POINT *EC_POINT_hex2point(const EC_GROUP *group, const char *hex,
                              EC_POINT *p, BN_CTX *ctx);&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&quot;DESCRIPTION&quot;&gt;DESCRIPTION&lt;/h1&gt;

&lt;p&gt;An &lt;b&gt;EC_POINT&lt;/b&gt; structure represents a point on a curve. A new point is constructed by calling the function EC_POINT_new() and providing the &lt;b&gt;group&lt;/b&gt; object that the point relates to.&lt;/p&gt;

&lt;p&gt;EC_POINT_free() frees the memory associated with the &lt;b&gt;EC_POINT&lt;/b&gt;. if &lt;b&gt;point&lt;/b&gt; is NULL nothing is done.&lt;/p&gt;

&lt;p&gt;EC_POINT_clear_free() destroys any sensitive data held within the EC_POINT and then frees its memory. If &lt;b&gt;point&lt;/b&gt; is NULL nothing is done.&lt;/p&gt;

&lt;p&gt;EC_POINT_copy() copies the point &lt;b&gt;src&lt;/b&gt; into &lt;b&gt;dst&lt;/b&gt;. Both &lt;b&gt;src&lt;/b&gt; and &lt;b&gt;dst&lt;/b&gt; must use the same &lt;b&gt;EC_METHOD&lt;/b&gt;.&lt;/p&gt;

&lt;p&gt;EC_POINT_dup() creates a new &lt;b&gt;EC_POINT&lt;/b&gt; object and copies the content from &lt;b&gt;src&lt;/b&gt; to the newly created &lt;b&gt;EC_POINT&lt;/b&gt; object.&lt;/p&gt;

&lt;p&gt;EC_POINT_method_of() obtains the &lt;b&gt;EC_METHOD&lt;/b&gt; associated with &lt;b&gt;point&lt;/b&gt;.&lt;/p&gt;

&lt;p&gt;A valid point on a curve is the special point at infinity. A point is set to be at infinity by calling EC_POINT_set_to_infinity().&lt;/p&gt;

&lt;p&gt;The affine co-ordinates for a point describe a point in terms of its x and y position. The function EC_POINT_set_affine_coordinates() sets the &lt;b&gt;x&lt;/b&gt; and &lt;b&gt;y&lt;/b&gt; co-ordinates for the point &lt;b&gt;p&lt;/b&gt; defined over the curve given in &lt;b&gt;group&lt;/b&gt;. The function EC_POINT_get_affine_coordinates() sets &lt;b&gt;x&lt;/b&gt; and &lt;b&gt;y&lt;/b&gt;, either of which may be NULL, to the corresponding coordinates of &lt;b&gt;p&lt;/b&gt;.&lt;/p&gt;

&lt;p&gt;The functions EC_POINT_set_affine_coordinates_GFp() and EC_POINT_set_affine_coordinates_GF2m() are synonyms for EC_POINT_set_affine_coordinates(). They are defined for backwards compatibility only and should not be used.&lt;/p&gt;

&lt;p&gt;The functions EC_POINT_get_affine_coordinates_GFp() and EC_POINT_get_affine_coordinates_GF2m() are synonyms for EC_POINT_get_affine_coordinates(). They are defined for backwards compatibility only and should not be used.&lt;/p&gt;

&lt;p&gt;As well as the affine co-ordinates, a point can alternatively be described in terms of its Jacobian projective co-ordinates (for Fp curves only). Jacobian projective co-ordinates are expressed as three values x, y and z. Working in this co-ordinate system provides more efficient point multiplication operations. A mapping exists between Jacobian projective co-ordinates and affine co-ordinates. A Jacobian projective co-ordinate (x, y, z) can be written as an affine co-ordinate as (x/(z^2), y/(z^3)). Conversion to Jacobian projective from affine co-ordinates is simple. The co-ordinate (x, y) is mapped to (x, y, 1). To set or get the projective co-ordinates use EC_POINT_set_Jprojective_coordinates_GFp() and EC_POINT_get_Jprojective_coordinates_GFp() respectively.&lt;/p&gt;

&lt;p&gt;Points can also be described in terms of their compressed co-ordinates. For a point (x, y), for any given value for x such that the point is on the curve there will only ever be two possible values for y. Therefore, a point can be set using the EC_POINT_set_compressed_coordinates() function where &lt;b&gt;x&lt;/b&gt; is the x co-ordinate and &lt;b&gt;y_bit&lt;/b&gt; is a value 0 or 1 to identify which of the two possible values for y should be used.&lt;/p&gt;

&lt;p&gt;The functions EC_POINT_set_compressed_coordinates_GFp() and EC_POINT_set_compressed_coordinates_GF2m() are synonyms for EC_POINT_set_compressed_coordinates(). They are defined for backwards compatibility only and should not be used.&lt;/p&gt;

&lt;p&gt;In addition &lt;b&gt;EC_POINT&lt;/b&gt; can be converted to and from various external representations. The octet form is the binary encoding of the &lt;b&gt;ECPoint&lt;/b&gt; structure (as defined in RFC5480 and used in certificates and TLS records): only the content octets are present, the &lt;b&gt;OCTET STRING&lt;/b&gt; tag and length are not included. &lt;b&gt;BIGNUM&lt;/b&gt; form is the octet form interpreted as a big endian integer converted to a &lt;b&gt;BIGNUM&lt;/b&gt; structure. Hexadecimal form is the octet form converted to a NULL terminated character string where each character is one of the printable values 0-9 or A-F (or a-f).&lt;/p&gt;

&lt;p&gt;The functions EC_POINT_point2oct(), EC_POINT_oct2point(), EC_POINT_point2bn(), EC_POINT_bn2point(), EC_POINT_point2hex() and EC_POINT_hex2point() convert from and to EC_POINTs for the formats: octet, BIGNUM and hexadecimal respectively.&lt;/p&gt;

&lt;p&gt;The function EC_POINT_point2oct() encodes the given curve point &lt;b&gt;p&lt;/b&gt; as an octet string into the buffer &lt;b&gt;buf&lt;/b&gt; of size &lt;b&gt;len&lt;/b&gt;, using the specified conversion form &lt;b&gt;form&lt;/b&gt;. The encoding conforms with Sec. 2.3.3 of the SECG SEC 1 (&amp;quot;Elliptic Curve Cryptography&amp;quot;) standard. Similarly the function EC_POINT_oct2point() decodes a curve point into &lt;b&gt;p&lt;/b&gt; from the octet string contained in the given buffer &lt;b&gt;buf&lt;/b&gt; of size &lt;b&gt;len&lt;/b&gt;, conforming to Sec. 2.3.4 of the SECG SEC 1 (&amp;quot;Elliptic Curve Cryptography&amp;quot;) standard.&lt;/p&gt;

&lt;p&gt;The functions EC_POINT_point2hex() and EC_POINT_point2bn() convert a point &lt;b&gt;p&lt;/b&gt;, respectively, to the hexadecimal or BIGNUM representation of the same encoding of the function EC_POINT_point2oct(). Vice versa, similarly to the function EC_POINT_oct2point(), the functions EC_POINT_hex2point() and EC_POINT_point2bn() decode the hexadecimal or BIGNUM representation into the EC_POINT &lt;b&gt;p&lt;/b&gt;.&lt;/p&gt;

&lt;p&gt;Notice that, according to the standard, the octet string encoding of the point at infinity for a given curve is fixed to a single octet of value zero and that, vice versa, a single octet of size zero is decoded as the point at infinity.&lt;/p&gt;

&lt;p&gt;The function EC_POINT_point2oct() must be supplied with a buffer long enough to store the octet form. The return value provides the number of octets stored. Calling the function with a NULL buffer will not perform the conversion but will still return the required buffer length.&lt;/p&gt;

&lt;p&gt;The function EC_POINT_point2buf() allocates a buffer of suitable length and writes an EC_POINT to it in octet format. The allocated buffer is written to &lt;b&gt;*pbuf&lt;/b&gt; and its length is returned. The caller must free up the allocated buffer with a call to OPENSSL_free(). Since the allocated buffer value is written to &lt;b&gt;*pbuf&lt;/b&gt; the &lt;b&gt;pbuf&lt;/b&gt; parameter &lt;b&gt;MUST NOT&lt;/b&gt; be &lt;b&gt;NULL&lt;/b&gt;.&lt;/p&gt;

&lt;p&gt;The function EC_POINT_point2hex() will allocate sufficient memory to store the hexadecimal string. It is the caller&amp;#39;s responsibility to free this memory with a subsequent call to OPENSSL_free().&lt;/p&gt;

&lt;h1 id=&quot;RETURN-VALUES&quot;&gt;RETURN VALUES&lt;/h1&gt;

&lt;p&gt;EC_POINT_new() and EC_POINT_dup() return the newly allocated EC_POINT or NULL on error.&lt;/p&gt;

&lt;p&gt;The following functions return 1 on success or 0 on error: EC_POINT_copy(), EC_POINT_set_to_infinity(), EC_POINT_set_Jprojective_coordinates_GFp(), EC_POINT_get_Jprojective_coordinates_GFp(), EC_POINT_set_affine_coordinates_GFp(), EC_POINT_get_affine_coordinates_GFp(), EC_POINT_set_compressed_coordinates_GFp(), EC_POINT_set_affine_coordinates_GF2m(), EC_POINT_get_affine_coordinates_GF2m(), EC_POINT_set_compressed_coordinates_GF2m() and EC_POINT_oct2point().&lt;/p&gt;

&lt;p&gt;EC_POINT_method_of returns the EC_METHOD associated with the supplied EC_POINT.&lt;/p&gt;

&lt;p&gt;EC_POINT_point2oct() and EC_POINT_point2buf() return the length of the required buffer or 0 on error.&lt;/p&gt;

&lt;p&gt;EC_POINT_point2bn() returns the pointer to the BIGNUM supplied, or NULL on error.&lt;/p&gt;

&lt;p&gt;EC_POINT_bn2point() returns the pointer to the EC_POINT supplied, or NULL on error.&lt;/p&gt;

&lt;p&gt;EC_POINT_point2hex() returns a pointer to the hex string, or NULL on error.&lt;/p&gt;

&lt;p&gt;EC_POINT_hex2point() returns the pointer to the EC_POINT supplied, or NULL on error.&lt;/p&gt;

&lt;h1 id=&quot;SEE-ALSO&quot;&gt;SEE ALSO&lt;/h1&gt;

&lt;p&gt;&lt;a href=&quot;../man7/crypto.html&quot;&gt;crypto(7)&lt;/a&gt;, &lt;a href=&quot;../man3/EC_GROUP_new.html&quot;&gt;EC_GROUP_new(3)&lt;/a&gt;, &lt;a href=&quot;../man3/EC_GROUP_copy.html&quot;&gt;EC_GROUP_copy(3)&lt;/a&gt;, &lt;a href=&quot;../man3/EC_POINT_add.html&quot;&gt;EC_POINT_add(3)&lt;/a&gt;, &lt;a href=&quot;../man3/EC_KEY_new.html&quot;&gt;EC_KEY_new(3)&lt;/a&gt;, &lt;a href=&quot;../man3/EC_GFp_simple_method.html&quot;&gt;EC_GFp_simple_method(3)&lt;/a&gt;, &lt;a href=&quot;../man3/d2i_ECPKParameters.html&quot;&gt;d2i_ECPKParameters(3)&lt;/a&gt;&lt;/p&gt;

&lt;h1 id=&quot;COPYRIGHT&quot;&gt;COPYRIGHT&lt;/h1&gt;

&lt;p&gt;Copyright 2013-2020 The OpenSSL Project Authors. All Rights Reserved.&lt;/p&gt;

&lt;p&gt;Licensed under the OpenSSL license (the &amp;quot;License&amp;quot;). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at &lt;a href=&quot;https://www.openssl.org/source/license.html&quot;&gt;https://www.openssl.org/source/license.html&lt;/a&gt;.&lt;/p&gt;


&lt;/body&gt;

&lt;/html&gt;


</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Fcpanel%2Fea-openssl11%2Fshare%2Fdoc%2Fopenssl%2Fhtml%2Fman3'>Back to Directory</a>