1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
//! Rust bindings to the [sodium library](https://github.com/jedisct1/libsodium).
//!
//! Sodium is a portable implementation of Dan Bernsteins [`NaCl`: Networking and
//! Cryptography library](http://nacl.cr.yp.to)
//!
//! For most users, if you want public-key (asymmetric) cryptography you should use
//! the functions in [`crypto::box_`](crypto/box_/index.html) for encryption/decryption.
//!
//! If you want secret-key (symmetric) cryptography you should be using the
//! functions in [`crypto::secretbox`](crypto/secretbox/index.html) for encryption/decryption.
//!
//! For public-key signatures you should use the functions in
//! [`crypto::sign`](crypto/sign/index.html) for signature creation and verification.
//!
//! Unless you know what you're doing you most certainly don't want to use the
//! functions in [`crypto::scalarmult`](crypto/scalarmult/index.html),
//! [`crypto::stream`](crypto/stream/index.html), [`crypto::auth`](crypto/auth/index.html) and
//! [`crypto::onetimeauth`](crypto/onetimeauth/index.html).
//!
//! ## Thread Safety
//! All functions in this library are thread-safe provided that the [`init()`](fn.init.html)
//! function has been called during program execution.
//!
//! If [`init()`](fn.init.html) hasn't been called then all functions except the random-number
//! generation functions and the key-generation functions are thread-safe.
//!
//! # Public-key cryptography
//! [`crypto::box_`](crypto/box_/index.html)
//!
//! [`crypto::sign`](crypto/sign/index.html)
//!
//! # Sealed boxes
//! [`crypto::sealedbox`](crypto/sealedbox/index.html)
//!
//! # Secret-key cryptography
//! [`crypto::secretbox`](crypto/secretbox/index.html)
//!
//! [`crypto::stream`](crypto/stream/index.html)
//!
//! [`crypto::auth`](crypto/auth/index.html)
//!
//! [`crypto::onetimeauth`](crypto/onetimeauth/index.html)
//!
//! # Low-level functions
//! [`crypto::hash`](crypto/hash/index.html)
//!
//! [`crypto::verify`](crypto/verify/index.html)
//!
//! [`crypto::shorthash`](crypto/shorthash/index.html)
#![crate_name = "sodiumoxide"]
#![crate_type = "lib"]
#![warn(missing_docs)]
#![warn(non_upper_case_globals)]
#![warn(non_camel_case_types)]
#![warn(unused_qualifications)]
#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(not(feature = "std"), feature(alloc))]
extern crate libsodium_sys as ffi;
extern crate libc;
#[cfg(test)]
extern crate rustc_serialize;
#[cfg(any(test, feature = "serde"))]
extern crate serde;
#[cfg(not(feature = "std"))]
#[macro_use]
extern crate alloc;
#[cfg(all(test, not(feature = "std")))]
extern crate std;
#[cfg(all(not(test), not(feature = "std")))]
mod std {
pub use core::{cmp, fmt, hash, iter, mem, ops, ptr, slice, str};
}
#[cfg(not(feature = "std"))]
mod prelude {
pub use alloc::string::String;
pub use alloc::vec::Vec;
}
/// `init()` initializes the sodium library and chooses faster versions of
/// the primitives if possible. `init()` also makes the random number generation
/// functions (`gen_key`, `gen_keypair`, `gen_nonce`, `randombytes`, `randombytes_into`)
/// thread-safe
///
/// `init()` returns `Ok` if initialization succeeded and `Err` if it failed.
pub fn init() -> Result<(), ()> {
if unsafe { ffi::sodium_init() } >= 0 {
Ok(())
} else {
Err(())
}
}
#[macro_use]
mod newtype_macros;
pub mod randombytes;
pub mod utils;
pub mod version;
#[cfg(test)]
mod test_utils;
/// Cryptographic functions
pub mod crypto {
pub mod aead;
pub mod auth;
pub mod box_;
pub mod generichash;
pub mod hash;
pub mod kx;
pub mod onetimeauth;
pub mod pwhash;
pub mod scalarmult;
pub mod sealedbox;
pub mod secretbox;
pub mod shorthash;
pub mod sign;
pub mod stream;
pub mod verify;
}