Standard preamble:
========================================================================
..
.... Set up some character translations and predefined strings. \*(-- will
give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
double quote, and \*(R" will give a right double quote. \*(C+ will
give a nicer C++. Capital omega is used to do unbreakable dashes and
therefore won't be available. \*(C` and \*(C' expand to `' in nroff,
nothing in troff, for use with C<>.
.tr \(*W- . ds -- \(*W- . ds PI pi . if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch . if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch . ds L" "" . ds R" "" . ds C` "" . ds C' "" 'br\} . ds -- \|\(em\| . ds PI \(*p . ds L" `` . ds R" '' . ds C` . ds C' 'br\}
Escape single quotes in literal strings from groff's Unicode transform.
If the F register is >0, we'll generate index entries on stderr for
titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
entries marked with X<> in POD. Of course, you'll have to process the
output yourself in some meaningful fashion.
Avoid warning from groff about undefined register 'F'.
.. .nr rF 0 . if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . if !\nF==2 \{\ . nr % 0 . nr F 2 . \} . \} .\} .rr rF
Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
Fear. Run. Save yourself. No user-serviceable parts.
. \" fudge factors for nroff and troff . ds #H 0 . ds #V .8m . ds #F .3m . ds #[ \f1 . ds #] .\} . ds #H ((1u-(\\\\n(.fu%2u))*.13m) . ds #V .6m . ds #F 0 . ds #[ \& . ds #] \& .\} . \" simple accents for nroff and troff . ds ' \& . ds ` \& . ds ^ \& . ds , \& . ds ~ ~ . ds / .\} . ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" . ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' . ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' . ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' . ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' . ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' .\} . \" troff and (daisy-wheel) nroff accents . \" corrections for vroff . \" for low resolution devices (crt and lpr) \{\ . ds : e . ds 8 ss . ds o a . ds d- d\h'-1'\(ga . ds D- D\h'-1'\(hy . ds th \o'bp' . ds Th \o'LP' . ds ae ae . ds Ae AE .\} ========================================================================
Title "EC_POINT_NEW 3"
way too many mistakes in technical documents.
\fBEC_POINT_free() frees the memory associated with the \s-1EC_POINT\s0. if point is \s-1NULL\s0 nothing is done.
\fBEC_POINT_clear_free() destroys any sensitive data held within the \s-1EC_POINT\s0 and then frees its memory. If point is \s-1NULL\s0 nothing is done.
\fBEC_POINT_copy() copies the point src into dst. Both src and dst must use the same \s-1EC_METHOD\s0.
\fBEC_POINT_dup() creates a new \s-1EC_POINT\s0 object and copies the content from \fBsrc to the newly created \s-1EC_POINT\s0 object.
\fBEC_POINT_method_of() obtains the \s-1EC_METHOD\s0 associated with point.
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().
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 x and y co-ordinates for the point p defined over the curve given in group. The function EC_POINT_get_affine_coordinates() sets x and y, either of which may be \s-1NULL,\s0 to the corresponding coordinates of p.
The functions EC_POINT_set_affine_coordinates_GFp() and \fBEC_POINT_set_affine_coordinates_GF2m() are synonyms for \fBEC_POINT_set_affine_coordinates(). They are defined for backwards compatibility only and should not be used.
The functions EC_POINT_get_affine_coordinates_GFp() and \fBEC_POINT_get_affine_coordinates_GF2m() are synonyms for \fBEC_POINT_get_affine_coordinates(). They are defined for backwards compatibility only and should not be used.
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 \fBEC_POINT_set_Jprojective_coordinates_GFp() and \fBEC_POINT_get_Jprojective_coordinates_GFp() respectively.
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 x is the x co-ordinate and y_bit is a value 0 or 1 to identify which of the two possible values for y should be used.
The functions EC_POINT_set_compressed_coordinates_GFp() and \fBEC_POINT_set_compressed_coordinates_GF2m() are synonyms for \fBEC_POINT_set_compressed_coordinates(). They are defined for backwards compatibility only and should not be used.
In addition \s-1EC_POINT\s0 can be converted to and from various external representations. The octet form is the binary encoding of the ECPoint structure (as defined in \s-1RFC5480\s0 and used in certificates and \s-1TLS\s0 records): only the content octets are present, the \s-1OCTET STRING\s0 tag and length are not included. \s-1BIGNUM\s0 form is the octet form interpreted as a big endian integer converted to a \s-1BIGNUM\s0 structure. Hexadecimal form is the octet form converted to a \s-1NULL\s0 terminated character string where each character is one of the printable values 0-9 or A-F (or a-f).
The functions EC_POINT_point2oct(), EC_POINT_oct2point(), EC_POINT_point2bn(), \fBEC_POINT_bn2point(), EC_POINT_point2hex() and EC_POINT_hex2point() convert from and to EC_POINTs for the formats: octet, \s-1BIGNUM\s0 and hexadecimal respectively.
The function EC_POINT_point2oct() encodes the given curve point p as an octet string into the buffer buf of size len, using the specified conversion form form. The encoding conforms with Sec. 2.3.3 of the \s-1SECG SEC 1\s0 (\*(L"Elliptic Curve Cryptography\*(R") standard. Similarly the function EC_POINT_oct2point() decodes a curve point into p from the octet string contained in the given buffer buf of size len, conforming to Sec. 2.3.4 of the \s-1SECG SEC 1\s0 (\*(L"Elliptic Curve Cryptography\*(R") standard.
The functions EC_POINT_point2hex() and EC_POINT_point2bn() convert a point p, respectively, to the hexadecimal or \s-1BIGNUM\s0 representation of the same encoding of the function EC_POINT_point2oct(). Vice versa, similarly to the function EC_POINT_oct2point(), the functions \fBEC_POINT_hex2point() and EC_POINT_point2bn() decode the hexadecimal or \s-1BIGNUM\s0 representation into the \s-1EC_POINT\s0 p.
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.
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 \s-1NULL\s0 buffer will not perform the conversion but will still return the required buffer length.
The function EC_POINT_point2buf() allocates a buffer of suitable length and writes an \s-1EC_POINT\s0 to it in octet format. The allocated buffer is written to \fB*pbuf 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 *pbuf the pbuf parameter \s-1MUST NOT\s0 be \s-1NULL\s0.
The function EC_POINT_point2hex() will allocate sufficient memory to store the hexadecimal string. It is the caller's responsibility to free this memory with a subsequent call to OPENSSL_free().
The following functions return 1 on success or 0 on error: EC_POINT_copy(), \fBEC_POINT_set_to_infinity(), EC_POINT_set_Jprojective_coordinates_GFp(), \fBEC_POINT_get_Jprojective_coordinates_GFp(), \fBEC_POINT_set_affine_coordinates_GFp(), EC_POINT_get_affine_coordinates_GFp(), \fBEC_POINT_set_compressed_coordinates_GFp(), \fBEC_POINT_set_affine_coordinates_GF2m(), EC_POINT_get_affine_coordinates_GF2m(), \fBEC_POINT_set_compressed_coordinates_GF2m() and EC_POINT_oct2point().
EC_POINT_method_of returns the \s-1EC_METHOD\s0 associated with the supplied \s-1EC_POINT.\s0
\fBEC_POINT_point2oct() and EC_POINT_point2buf() return the length of the required buffer or 0 on error.
\fBEC_POINT_point2bn() returns the pointer to the \s-1BIGNUM\s0 supplied, or \s-1NULL\s0 on error.
\fBEC_POINT_bn2point() returns the pointer to the \s-1EC_POINT\s0 supplied, or \s-1NULL\s0 on error.
\fBEC_POINT_point2hex() returns a pointer to the hex string, or \s-1NULL\s0 on error.
\fBEC_POINT_hex2point() returns the pointer to the \s-1EC_POINT\s0 supplied, or \s-1NULL\s0 on error.
Licensed under the OpenSSL license (the \*(L"License\*(R"). You may not use this file except in compliance with the License. You can obtain a copy in the file \s-1LICENSE\s0 in the source distribution or at <https://www.openssl.org/source/license.html>.