naclite.h

Go to the documentation of this file.

// naclite.h - written and placed in the public domain by Jeffrey Walton
//          based on public domain NaCl source code written by
//          Daniel J. Bernstein, Bernard van Gastel, Wesley Janssen,
//          Tanja Lange, Peter Schwabe and Sjaak Smetsers.
 
// The Tweet API was added to the Crypto++ library to cross-validate results.
// We debated over putting it in the Test namespace, but settled for the NaCl
// namespace to segregate it from other parts of the library.
 
 
#ifndef CRYPTOPP_NACL_H
#define CRYPTOPP_NACL_H
 
#include "config.h"
#include "stdcpp.h"
 
#if defined(NO_OS_DEPENDENCE) || !defined(OS_RNG_AVAILABLE)
# define CRYPTOPP_DISABLE_NACL 1
#endif
 
#ifndef CRYPTOPP_DISABLE_NACL
 
NAMESPACE_BEGIN(CryptoPP)
NAMESPACE_BEGIN(NaCl)
 
 
CRYPTOPP_CONSTANT(crypto_hash_BYTES = 64);
 
CRYPTOPP_CONSTANT(crypto_stream_KEYBYTES = 32);
CRYPTOPP_CONSTANT(crypto_stream_NONCEBYTES = 24);
 
CRYPTOPP_CONSTANT(crypto_auth_KEYBYTES = 32);
CRYPTOPP_CONSTANT(crypto_auth_BYTES = 16);
 
CRYPTOPP_CONSTANT(crypto_onetimeauth_KEYBYTES = 32);
CRYPTOPP_CONSTANT(crypto_onetimeauth_BYTES = 16);
 
CRYPTOPP_CONSTANT(crypto_secretbox_KEYBYTES = 32);
CRYPTOPP_CONSTANT(crypto_secretbox_NONCEBYTES = 24);
CRYPTOPP_CONSTANT(crypto_secretbox_ZEROBYTES = 32);
CRYPTOPP_CONSTANT(crypto_secretbox_BOXZEROBYTES = 16);
 
CRYPTOPP_CONSTANT(crypto_box_SECRETKEYBYTES = 32);
CRYPTOPP_CONSTANT(crypto_box_PUBLICKEYBYTES = 32);
CRYPTOPP_CONSTANT(crypto_box_NONCEBYTES = 24);
CRYPTOPP_CONSTANT(crypto_box_ZEROBYTES = 32);
CRYPTOPP_CONSTANT(crypto_box_BOXZEROBYTES = 16);
CRYPTOPP_CONSTANT(crypto_box_BEFORENMBYTES = 32);
CRYPTOPP_CONSTANT(crypto_box_MACBYTES = 16);
 
CRYPTOPP_CONSTANT(crypto_sign_SECRETKEYBYTES = 64);
CRYPTOPP_CONSTANT(crypto_sign_PUBLICKEYBYTES = 32);
CRYPTOPP_CONSTANT(crypto_sign_SEEDBYTES = 32);
CRYPTOPP_CONSTANT(crypto_sign_BYTES = 64);
 
CRYPTOPP_CONSTANT(crypto_scalarmult_BYTES = 32);
CRYPTOPP_CONSTANT(crypto_scalarmult_SCALARBYTES = 32);
 
int crypto_box(byte *c,const byte *m,word64 d,const byte *n,const byte *y,const byte *x);
 
int crypto_box_open(byte *m,const byte *c,word64 d,const byte *n,const byte *y,const byte *x);
 
int crypto_box_keypair(byte *y,byte *x);
 
int crypto_box_beforenm(byte *k,const byte *y,const byte *x);
 
int crypto_box_afternm(byte *c,const byte *m,word64 d,const byte *n,const byte *k);
 
int crypto_box_open_afternm(byte *m,const byte *c,word64 d,const byte *n,const byte *k);
 
int crypto_box_unchecked(byte *c,const byte *m,word64 d,const byte *n,const byte *y,const byte *x);
 
int crypto_box_open_unchecked(byte *m,const byte *c,word64 d,const byte *n,const byte *y,const byte *x);
 
int crypto_box_beforenm_unchecked(byte *k,const byte *y,const byte *x);
 
int crypto_core_salsa20(byte *out,const byte *in,const byte *k,const byte *c);
 
int crypto_core_hsalsa20(byte *out,const byte *in,const byte *k,const byte *c);
 
int crypto_hashblocks(byte *x,const byte *m,word64 n);
 
int crypto_hash(byte *out,const byte *m,word64 n);
 
int crypto_onetimeauth(byte *out,const byte *m,word64 n,const byte *k);
 
int crypto_onetimeauth_verify(const byte *h,const byte *m,word64 n,const byte *k);
 
int crypto_scalarmult(byte *q,const byte *n,const byte *p);
 
int crypto_scalarmult_base(byte *q,const byte *n);
 
int crypto_secretbox(byte *c,const byte *m,word64 d,const byte *n,const byte *k);
 
int crypto_secretbox_open(byte *m,const byte *c,word64 d,const byte *n,const byte *k);
 
int crypto_sign(byte *sm,word64 *smlen,const byte *m,word64 n,const byte *sk);
 
int crypto_sign_open(byte *m,word64 *mlen,const byte *sm,word64 n,const byte *pk);
 
int crypto_sign_keypair(byte *pk, byte *sk);
 
int crypto_sign_sk2pk(byte *pk, const byte *sk);
 
int crypto_stream(byte *c,word64 d,const byte *n,const byte *k);
 
int crypto_stream_xor(byte *c,const byte *m,word64 d,const byte *n,const byte *k);
 
int crypto_stream_salsa20(byte *c,word64 d,const byte *n,const byte *k);
 
int crypto_stream_salsa20_xor(byte *c,const byte *m,word64 b,const byte *n,const byte *k);
 
int crypto_verify_16(const byte *x,const byte *y);
 
int crypto_verify_32(const byte *x,const byte *y);
 
NAMESPACE_END  // CryptoPP
NAMESPACE_END  // NaCl
 
#endif  // CRYPTOPP_DISABLE_NACL
#endif  // CRYPTOPP_NACL_H