milksad
/
rust-secp256k1-unsafe-fast
14
0
Fork 0
Code Issues Pull Requests Activity

Add period to sentences 

Add the terminating period to all docs sentences. (Also one instance of
capitialize initial character in sentence.)
This commit is contained in:
Tobin Harding 2021-11-18 10:52:28 +11:00
parent 269bde042f
commit 5e07e7596b
No known key found for this signature in database
GPG Key ID: 40BF9E4C269D6607
6 changed files with 43 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/constants.rs
View File

@ -14,7 +14,7 @@
// //
//! # Constants //! # Constants
//! Constants related to the API and the underlying curve //! Constants related to the API and the underlying curve.
/// The size (in bytes) of a message /// The size (in bytes) of a message
pub const MESSAGE_SIZE: usize = 32; pub const MESSAGE_SIZE: usize = 32;
@ -51,7 +51,7 @@ pub const FIELD_SIZE: [u8; 32] = [
0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f
]; ];
/// The order of the secp256k1 curve /// The order of the secp256k1 curve.
pub const CURVE_ORDER: [u8; 32] = [ pub const CURVE_ORDER: [u8; 32] = [
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
@ -59,7 +59,7 @@ pub const CURVE_ORDER: [u8; 32] = [
0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41
]; ];
/// The X coordinate of the generator /// The X coordinate of the generator.
pub const GENERATOR_X: [u8; 32] = [ pub const GENERATOR_X: [u8; 32] = [
0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac, 0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac,
0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b, 0x07, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b, 0x07,
@ -67,7 +67,7 @@ pub const GENERATOR_X: [u8; 32] = [
0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98
]; ];
/// The Y coordinate of the generator /// The Y coordinate of the generator.
pub const GENERATOR_Y: [u8; 32] = [ pub const GENERATOR_Y: [u8; 32] = [
0x48, 0x3a, 0xda, 0x77, 0x26, 0xa3, 0xc4, 0x65, 0x48, 0x3a, 0xda, 0x77, 0x26, 0xa3, 0xc4, 0x65,
0x5d, 0xa4, 0xfb, 0xfc, 0x0e, 0x11, 0x08, 0xa8, 0x5d, 0xa4, 0xfb, 0xfc, 0x0e, 0x11, 0x08, 0xa8,

24
src/context.rs
View File

@ -11,7 +11,7 @@ pub use self::alloc_only::*;
#[cfg(all(feature = "global-context", feature = "std"))] #[cfg(all(feature = "global-context", feature = "std"))]
#[cfg_attr(docsrs, doc(cfg(all(feature = "global-context", feature = "std"))))] #[cfg_attr(docsrs, doc(cfg(all(feature = "global-context", feature = "std"))))]
/// Module implementing a singleton pattern for a global `Secp256k1` context /// Module implementing a singleton pattern for a global `Secp256k1` context.
pub mod global { pub mod global {
#[cfg(feature = "rand-std")] #[cfg(feature = "rand-std")]
use rand; use rand;
@ -20,7 +20,7 @@ pub mod global {
use std::sync::Once; use std::sync::Once;
use {Secp256k1, All}; use {Secp256k1, All};
/// Proxy struct for global `SECP256K1` context /// Proxy struct for global `SECP256K1` context.
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub struct GlobalContext { pub struct GlobalContext {
__private: (), __private: (),
@ -98,8 +98,8 @@ pub struct AllPreallocated<'buf> {
mod private { mod private {
use super::*; use super::*;
// A trick to prevent users from implementing a trait. // A trick to prevent users from implementing a trait.
// on one hand this trait is public, on the other it's in a private module // On one hand this trait is public, on the other it's in a private module
// so it's not visible to anyone besides it's parent (the context module) // so it's not visible to anyone besides it's parent (the context module).
pub trait Sealed {} pub trait Sealed {}
impl<'buf> Sealed for AllPreallocated<'buf> {} impl<'buf> Sealed for AllPreallocated<'buf> {}
@ -289,7 +289,7 @@ unsafe impl<'buf> Context for VerifyOnlyPreallocated<'buf> {
const DESCRIPTION: &'static str = "verification only"; const DESCRIPTION: &'static str = "verification only";
unsafe fn deallocate(_ptr: *mut u8, _size: usize) { unsafe fn deallocate(_ptr: *mut u8, _size: usize) {
// Allocated by the user // Allocated by the user.
} }
} }
@ -298,7 +298,7 @@ unsafe impl<'buf> Context for AllPreallocated<'buf> {
const DESCRIPTION: &'static str = "all capabilities"; const DESCRIPTION: &'static str = "all capabilities";
unsafe fn deallocate(_ptr: *mut u8, _size: usize) { unsafe fn deallocate(_ptr: *mut u8, _size: usize) {
// Allocated by the user // Allocated by the user.
} }
} }
@ -328,7 +328,7 @@ impl<'buf> Secp256k1<AllPreallocated<'buf>> {
pub fn preallocated_new(buf: &'buf mut [AlignedType]) -> Result<Secp256k1<AllPreallocated<'buf>>, Error> { pub fn preallocated_new(buf: &'buf mut [AlignedType]) -> Result<Secp256k1<AllPreallocated<'buf>>, Error> {
Secp256k1::preallocated_gen_new(buf) Secp256k1::preallocated_gen_new(buf)
} }
/// Uses the ffi `secp256k1_context_preallocated_size` to check the memory size needed for a context /// Uses the ffi `secp256k1_context_preallocated_size` to check the memory size needed for a context.
pub fn preallocate_size() -> usize { pub fn preallocate_size() -> usize {
Self::preallocate_size_gen() Self::preallocate_size_gen()
} }
@ -354,12 +354,12 @@ impl<'buf> Secp256k1<AllPreallocated<'buf>> {
} }
impl<'buf> Secp256k1<SignOnlyPreallocated<'buf>> { impl<'buf> Secp256k1<SignOnlyPreallocated<'buf>> {
/// Creates a new Secp256k1 context that can only be used for signing /// Creates a new Secp256k1 context that can only be used for signing.
pub fn preallocated_signing_only(buf: &'buf mut [AlignedType]) -> Result<Secp256k1<SignOnlyPreallocated<'buf>>, Error> { pub fn preallocated_signing_only(buf: &'buf mut [AlignedType]) -> Result<Secp256k1<SignOnlyPreallocated<'buf>>, Error> {
Secp256k1::preallocated_gen_new(buf) Secp256k1::preallocated_gen_new(buf)
} }
/// Uses the ffi `secp256k1_context_preallocated_size` to check the memory size needed for the context /// Uses the ffi `secp256k1_context_preallocated_size` to check the memory size needed for the context.
#[inline] #[inline]
pub fn preallocate_signing_size() -> usize { pub fn preallocate_signing_size() -> usize {
Self::preallocate_size_gen() Self::preallocate_size_gen()
@ -374,7 +374,7 @@ impl<'buf> Secp256k1<SignOnlyPreallocated<'buf>> {
/// * The capabilities (All/SignOnly/VerifyOnly) of the context *must* match the flags passed to libsecp256k1 /// * The capabilities (All/SignOnly/VerifyOnly) of the context *must* match the flags passed to libsecp256k1
/// when generating the context. /// when generating the context.
/// * The user must handle the freeing of the context(using the correct functions) by himself. /// * The user must handle the freeing of the context(using the correct functions) by himself.
/// * This list *is not* exhaustive, and any violation may lead to Undefined Behavior., /// * This list *is not* exhaustive, and any violation may lead to Undefined Behavior.
/// ///
pub unsafe fn from_raw_signining_only(raw_ctx: *mut ffi::Context) -> ManuallyDrop<Secp256k1<SignOnlyPreallocated<'buf>>> { pub unsafe fn from_raw_signining_only(raw_ctx: *mut ffi::Context) -> ManuallyDrop<Secp256k1<SignOnlyPreallocated<'buf>>> {
ManuallyDrop::new(Secp256k1 { ManuallyDrop::new(Secp256k1 {
@ -391,7 +391,7 @@ impl<'buf> Secp256k1<VerifyOnlyPreallocated<'buf>> {
Secp256k1::preallocated_gen_new(buf) Secp256k1::preallocated_gen_new(buf)
} }
/// Uses the ffi `secp256k1_context_preallocated_size` to check the memory size needed for the context /// Uses the ffi `secp256k1_context_preallocated_size` to check the memory size needed for the context.
#[inline] #[inline]
pub fn preallocate_verification_size() -> usize { pub fn preallocate_verification_size() -> usize {
Self::preallocate_size_gen() Self::preallocate_size_gen()
@ -406,7 +406,7 @@ impl<'buf> Secp256k1<VerifyOnlyPreallocated<'buf>> {
/// * The capabilities (All/SignOnly/VerifyOnly) of the context *must* match the flags passed to libsecp256k1 /// * The capabilities (All/SignOnly/VerifyOnly) of the context *must* match the flags passed to libsecp256k1
/// when generating the context. /// when generating the context.
/// * The user must handle the freeing of the context(using the correct functions) by himself. /// * The user must handle the freeing of the context(using the correct functions) by himself.
/// * This list *is not* exhaustive, and any violation may lead to Undefined Behavior., /// * This list *is not* exhaustive, and any violation may lead to Undefined Behavior.
/// ///
pub unsafe fn from_raw_verification_only(raw_ctx: *mut ffi::Context) -> ManuallyDrop<Secp256k1<VerifyOnlyPreallocated<'buf>>> { pub unsafe fn from_raw_verification_only(raw_ctx: *mut ffi::Context) -> ManuallyDrop<Secp256k1<VerifyOnlyPreallocated<'buf>>> {
ManuallyDrop::new(Secp256k1 { ManuallyDrop::new(Secp256k1 {

2
src/ecdh.rs
View File

@ -13,7 +13,7 @@
// //
//! # ECDH //! # ECDH
//! Support for shared secret computations //! Support for shared secret computations.
//! //!
use core::ptr; use core::ptr;

19
src/ecdsa/recovery.rs
View File

@ -25,11 +25,11 @@ use ffi::recovery as ffi;
use super::*; use super::*;
use {Verification, Secp256k1, Signing, Message}; use {Verification, Secp256k1, Signing, Message};
/// A tag used for recovering the public key from a compact signature /// A tag used for recovering the public key from a compact signature.
#[derive(Copy, Clone, PartialEq, Eq, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct RecoveryId(i32); pub struct RecoveryId(i32);
/// An ECDSA signature with a recovery ID for pubkey recovery /// An ECDSA signature with a recovery ID for pubkey recovery.
#[derive(Copy, Clone, PartialEq, Eq, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct RecoverableSignature(ffi::RecoverableSignature); pub struct RecoverableSignature(ffi::RecoverableSignature);
@ -53,8 +53,7 @@ pub fn to_i32(self) -> i32 {
impl RecoverableSignature { impl RecoverableSignature {
#[inline] #[inline]
/// Converts a compact-encoded byte slice to a signature. This /// Converts a compact-encoded byte slice to a signature. This
/// representation is nonstandard and defined by the libsecp256k1 /// representation is nonstandard and defined by the libsecp256k1 library.
/// library.
pub fn from_compact(data: &[u8], recid: RecoveryId) -> Result<RecoverableSignature, Error> { pub fn from_compact(data: &[u8], recid: RecoveryId) -> Result<RecoverableSignature, Error> {
if data.is_empty() {return Err(Error::InvalidSignature);} if data.is_empty() {return Err(Error::InvalidSignature);}
@ -77,20 +76,20 @@ impl RecoverableSignature {
} }
} }
/// Obtains a raw pointer suitable for use with FFI functions /// Obtains a raw pointer suitable for use with FFI functions.
#[inline] #[inline]
pub fn as_ptr(&self) -> *const ffi::RecoverableSignature { pub fn as_ptr(&self) -> *const ffi::RecoverableSignature {
&self.0 &self.0
} }
/// Obtains a raw mutable pointer suitable for use with FFI functions /// Obtains a raw mutable pointer suitable for use with FFI functions.
#[inline] #[inline]
pub fn as_mut_ptr(&mut self) -> *mut ffi::RecoverableSignature { pub fn as_mut_ptr(&mut self) -> *mut ffi::RecoverableSignature {
&mut self.0 &mut self.0
} }
#[inline] #[inline]
/// Serializes the recoverable signature in compact format /// Serializes the recoverable signature in compact format.
pub fn serialize_compact(&self) -> (RecoveryId, [u8; 64]) { pub fn serialize_compact(&self) -> (RecoveryId, [u8; 64]) {
let mut ret = [0u8; 64]; let mut ret = [0u8; 64];
let mut recid = 0i32; let mut recid = 0i32;
@ -107,7 +106,7 @@ impl RecoverableSignature {
} }
/// Converts a recoverable signature to a non-recoverable one (this is needed /// Converts a recoverable signature to a non-recoverable one (this is needed
/// for verification /// for verification).
#[inline] #[inline]
pub fn to_standard(&self) -> Signature { pub fn to_standard(&self) -> Signature {
unsafe { unsafe {
@ -135,7 +134,7 @@ impl CPtr for RecoverableSignature {
} }
} }
/// Creates a new recoverable signature from a FFI one /// Creates a new recoverable signature from a FFI one.
impl From<ffi::RecoverableSignature> for RecoverableSignature { impl From<ffi::RecoverableSignature> for RecoverableSignature {
#[inline] #[inline]
fn from(sig: ffi::RecoverableSignature) -> RecoverableSignature { fn from(sig: ffi::RecoverableSignature) -> RecoverableSignature {
@ -144,7 +143,7 @@ impl From<ffi::RecoverableSignature> for RecoverableSignature {
} }
impl<C: Signing> Secp256k1<C> { impl<C: Signing> Secp256k1<C> {
/// Constructs a signature for `msg` using the secret key `sk` and RFC6979 nonce /// Constructs a signature for `msg` using the secret key `sk` and RFC6979 nonce.
/// Requires a signing-capable context. /// Requires a signing-capable context.
#[deprecated(since = "0.21.0", note = "Use sign_ecdsa_recoverable instead.")] #[deprecated(since = "0.21.0", note = "Use sign_ecdsa_recoverable instead.")]
pub fn sign_recoverable(&self, msg: &Message, sk: &key::SecretKey) -> RecoverableSignature { pub fn sign_recoverable(&self, msg: &Message, sk: &key::SecretKey) -> RecoverableSignature {

4
src/key.rs
View File

@ -57,7 +57,7 @@ impl str::FromStr for SecretKey {
} }
} }
/// The number 1 encoded as a secret key /// The number 1 encoded as a secret key.
pub const ONE_KEY: SecretKey = SecretKey([0, 0, 0, 0, 0, 0, 0, 0, pub const ONE_KEY: SecretKey = SecretKey([0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@ -344,7 +344,7 @@ impl PublicKey {
unsafe { unsafe {
let mut pk = ffi::PublicKey::new(); let mut pk = ffi::PublicKey::new();
// We can assume the return value because it's not possible to construct // We can assume the return value because it's not possible to construct
// an invalid `SecretKey` without transmute trickery or something // an invalid `SecretKey` without transmute trickery or something.
let res = ffi::secp256k1_ec_pubkey_create(secp.ctx, &mut pk, sk.as_c_ptr()); let res = ffi::secp256k1_ec_pubkey_create(secp.ctx, &mut pk, sk.as_c_ptr());
debug_assert_eq!(res, 1); debug_assert_eq!(res, 1);
PublicKey(pk) PublicKey(pk)

30
src/lib.rs
View File

@ -205,7 +205,7 @@ pub use context::global::SECP256K1;
use hashes::Hash; use hashes::Hash;
// Backwards compatible changes // Backwards compatible changes
/// Schnorr Sig related methods /// Schnorr Signature related methods.
#[deprecated(since = "0.21.0", note = "Use schnorr instead.")] #[deprecated(since = "0.21.0", note = "Use schnorr instead.")]
pub mod schnorrsig { pub mod schnorrsig {
#[deprecated(since = "0.21.0", note = "Use crate::XOnlyPublicKey instead.")] #[deprecated(since = "0.21.0", note = "Use crate::XOnlyPublicKey instead.")]
@ -255,7 +255,7 @@ impl<T: hashes::sha256t::Tag> ThirtyTwoByteHash for hashes::sha256t::Hash<T> {
} }
} }
/// A (hashed) message input to an ECDSA signature /// A (hashed) message input to an ECDSA signature.
pub struct Message([u8; constants::MESSAGE_SIZE]); pub struct Message([u8; constants::MESSAGE_SIZE]);
impl_array_newtype!(Message, u8, constants::MESSAGE_SIZE); impl_array_newtype!(Message, u8, constants::MESSAGE_SIZE);
impl_pretty_debug!(Message); impl_pretty_debug!(Message);
@ -302,7 +302,7 @@ impl Message {
} }
impl<T: ThirtyTwoByteHash> From<T> for Message { impl<T: ThirtyTwoByteHash> From<T> for Message {
/// Converts a 32-byte hash directly to a message without error paths /// Converts a 32-byte hash directly to a message without error paths.
fn from(t: T) -> Message { fn from(t: T) -> Message {
Message(t.into_32()) Message(t.into_32())
} }
@ -314,21 +314,21 @@ pub enum Error {
/// Signature failed verification /// Signature failed verification
IncorrectSignature, IncorrectSignature,
/// Badly sized message ("messages" are actually fixed-sized digests; see the `MESSAGE_SIZE` /// Badly sized message ("messages" are actually fixed-sized digests; see the `MESSAGE_SIZE`
/// constant) /// constant).
InvalidMessage, InvalidMessage,
/// Bad public key /// Bad public key.
InvalidPublicKey, InvalidPublicKey,
/// Bad signature /// Bad signature.
InvalidSignature, InvalidSignature,
/// Bad secret key /// Bad secret key.
InvalidSecretKey, InvalidSecretKey,
/// Bad recovery id /// Bad recovery id.
InvalidRecoveryId, InvalidRecoveryId,
/// Invalid tweak for add_*_assign or mul_*_assign /// Invalid tweak for add_*_assign or mul_*_assign
InvalidTweak, InvalidTweak,
/// Didn't pass enough memory to context creation with preallocated memory /// Didn't pass enough memory to context creation with preallocated memory.
NotEnoughMemory, NotEnoughMemory,
/// Bad set of public keys /// Bad set of public keys.
InvalidPublicKeySum, InvalidPublicKeySum,
/// The only valid parity values are 0 or 1. /// The only valid parity values are 0 or 1.
InvalidParityValue, InvalidParityValue,
@ -351,7 +351,7 @@ impl Error {
} }
} }
// Passthrough Debug to Display, since errors should be user-visible // Passthrough Debug to Display, since errors should be user-visible.
impl fmt::Display for Error { impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
f.write_str(self.as_str()) f.write_str(self.as_str())
@ -363,16 +363,16 @@ impl fmt::Display for Error {
impl std::error::Error for Error {} impl std::error::Error for Error {}
/// The secp256k1 engine, used to execute all signature operations /// The secp256k1 engine, used to execute all signature operations.
pub struct Secp256k1<C: Context> { pub struct Secp256k1<C: Context> {
ctx: *mut ffi::Context, ctx: *mut ffi::Context,
phantom: PhantomData<C>, phantom: PhantomData<C>,
size: usize, size: usize,
} }
// The underlying secp context does not contain any references to memory it does not own // The underlying secp context does not contain any references to memory it does not own.
unsafe impl<C: Context> Send for Secp256k1<C> {} unsafe impl<C: Context> Send for Secp256k1<C> {}
// The API does not permit any mutation of `Secp256k1` objects except through `&mut` references // The API does not permit any mutation of `Secp256k1` objects except through `&mut` references.
unsafe impl<C: Context> Sync for Secp256k1<C> {} unsafe impl<C: Context> Sync for Secp256k1<C> {}
impl<C: Context> PartialEq for Secp256k1<C> { impl<C: Context> PartialEq for Secp256k1<C> {
@ -406,7 +406,7 @@ impl<C: Context> Secp256k1<C> {
&self.ctx &self.ctx
} }
/// Returns the required memory for a preallocated context buffer in a generic manner(sign/verify/all) /// Returns the required memory for a preallocated context buffer in a generic manner(sign/verify/all).
pub fn preallocate_size_gen() -> usize { pub fn preallocate_size_gen() -> usize {
let word_size = mem::size_of::<AlignedType>(); let word_size = mem::size_of::<AlignedType>();
let bytes = unsafe { ffi::secp256k1_context_preallocated_size(C::FLAGS) }; let bytes = unsafe { ffi::secp256k1_context_preallocated_size(C::FLAGS) };