kris/pqc
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Include full clangformat config.

Browse Source 
Hopefully stabilizes behaviour between versions.
This commit is contained in:
Thom Wiggers 2019-02-11 10:05:54 +01:00
parent 69e593427a
commit fe46514836
No known key found for this signature in database
GPG Key ID: 001BB0A7CE26E363
5 changed files with 351 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
.clang-format
View File

@ -1,7 +1,115 @@
--- ---
Language: Cpp Language: Cpp
BasedOnStyle: LLVM AccessModifierOffset: -2
AllowShortFunctionsOnASingleLine: false AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: None
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
AfterClass: false
AfterControlStatement: false
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 3
- Regex: '.*'
Priority: 1
IncludeIsMainRegex: '(Test)?$'
IndentCaseLabels: false
IndentPPDirectives: None
IndentWidth: 4 IndentWidth: 4
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp11
TabWidth: 8
UseTab: Never
... ...

128
common/randombytes.c
View File

@ -26,86 +26,83 @@ THE SOFTWARE.
// *before* randombytes.h is included. Otherwise SYS_getrandom will not be // *before* randombytes.h is included. Otherwise SYS_getrandom will not be
// declared. // declared.
#if defined(__linux__) #if defined(__linux__)
# define _GNU_SOURCE #define _GNU_SOURCE
#endif /* defined(__linux__) */ #endif /* defined(__linux__) */
#include "randombytes.h" #include "randombytes.h"
#if defined(_WIN32) #if defined(_WIN32)
/* Windows */ /* Windows */
# include <windows.h> #include <wincrypt.h> /* CryptAcquireContext, CryptGenRandom */
# include <wincrypt.h> /* CryptAcquireContext, CryptGenRandom */ #include <windows.h>
#endif /* defined(_WIN32) */ #endif /* defined(_WIN32) */
#if defined(__linux__) #if defined(__linux__)
/* Linux */ /* Linux */
// We would need to include <linux/random.h>, but not every target has access // We would need to include <linux/random.h>, but not every target has access
// to the linux headers. We only need RNDGETENTCNT, so we instead inline it. // to the linux headers. We only need RNDGETENTCNT, so we instead inline it.
// RNDGETENTCNT is originally defined in `include/uapi/linux/random.h` in the // RNDGETENTCNT is originally defined in `include/uapi/linux/random.h` in the
// linux repo. // linux repo.
# define RNDGETENTCNT 0x80045200 #define RNDGETENTCNT 0x80045200
# include <assert.h> #include <assert.h>
# include <errno.h> #include <errno.h>
# include <fcntl.h> #include <fcntl.h>
# include <poll.h> #include <poll.h>
# include <stdint.h> #include <stdint.h>
# include <stdio.h> #include <stdio.h>
# include <sys/ioctl.h> #include <sys/ioctl.h>
# include <sys/stat.h> #include <sys/stat.h>
# include <sys/syscall.h> #include <sys/syscall.h>
# include <sys/types.h> #include <sys/types.h>
# include <unistd.h> #include <unistd.h>
// We need SSIZE_MAX as the maximum read len from /dev/urandom // We need SSIZE_MAX as the maximum read len from /dev/urandom
# if !defined(SSIZE_MAX) #if !defined(SSIZE_MAX)
# define SSIZE_MAX (SIZE_MAX / 2 - 1) #define SSIZE_MAX (SIZE_MAX / 2 - 1)
# endif /* defined(SSIZE_MAX) */ #endif /* defined(SSIZE_MAX) */
#endif /* defined(__linux__) */ #endif /* defined(__linux__) */
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
/* Dragonfly, FreeBSD, NetBSD, OpenBSD (has arc4random) */ /* Dragonfly, FreeBSD, NetBSD, OpenBSD (has arc4random) */
# include <sys/param.h> #include <sys/param.h>
# if defined(BSD) #if defined(BSD)
# include <stdlib.h> #include <stdlib.h>
# endif #endif
#endif #endif
#if defined(__EMSCRIPTEN__) #if defined(__EMSCRIPTEN__)
# include <assert.h> #include <assert.h>
# include <emscripten.h> #include <emscripten.h>
# include <errno.h> #include <errno.h>
# include <stdbool.h> #include <stdbool.h>
#endif /* defined(__EMSCRIPTEN__) */ #endif /* defined(__EMSCRIPTEN__) */
#if defined(_WIN32) #if defined(_WIN32)
static int randombytes_win32_randombytes(void* buf, const size_t n) static int randombytes_win32_randombytes(void *buf, const size_t n) {
{
HCRYPTPROV ctx; HCRYPTPROV ctx;
BOOL tmp; BOOL tmp;
tmp = CryptAcquireContext(&ctx, NULL, NULL, PROV_RSA_FULL, tmp = CryptAcquireContext(&ctx, NULL, NULL, PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT); CRYPT_VERIFYCONTEXT);
if (tmp == FALSE) return -1; if (tmp == FALSE)
return -1;
tmp = CryptGenRandom(ctx, n, (BYTE*) buf); tmp = CryptGenRandom(ctx, n, (BYTE *)buf);
if (tmp == FALSE) return -1; if (tmp == FALSE)
return -1;
tmp = CryptReleaseContext(ctx, 0); tmp = CryptReleaseContext(ctx, 0);
if (tmp == FALSE) return -1; if (tmp == FALSE)
return -1;
return 0; return 0;
} }
#endif /* defined(_WIN32) */ #endif /* defined(_WIN32) */
#if defined(__linux__) && defined(SYS_getrandom) #if defined(__linux__) && defined(SYS_getrandom)
static int randombytes_linux_randombytes_getrandom(void *buf, size_t n) static int randombytes_linux_randombytes_getrandom(void *buf, size_t n) {
{
/* I have thought about using a separate PRF, seeded by getrandom, but /* I have thought about using a separate PRF, seeded by getrandom, but
* it turns out that the performance of getrandom is good enough * it turns out that the performance of getrandom is good enough
* (250 MB/s on my laptop). * (250 MB/s on my laptop).
@ -129,15 +126,12 @@ static int randombytes_linux_randombytes_getrandom(void *buf, size_t n)
} }
#endif /* defined(__linux__) && defined(SYS_getrandom) */ #endif /* defined(__linux__) && defined(SYS_getrandom) */
#if defined(__linux__) && !defined(SYS_getrandom) #if defined(__linux__) && !defined(SYS_getrandom)
static int randombytes_linux_read_entropy_ioctl(int device, int *entropy) static int randombytes_linux_read_entropy_ioctl(int device, int *entropy) {
{
return ioctl(device, RNDGETENTCNT, entropy); return ioctl(device, RNDGETENTCNT, entropy);
} }
static int randombytes_linux_read_entropy_proc(FILE *stream, int *entropy) static int randombytes_linux_read_entropy_proc(FILE *stream, int *entropy) {
{
int retcode; int retcode;
do { do {
rewind(stream); rewind(stream);
@ -149,8 +143,7 @@ static int randombytes_linux_read_entropy_proc(FILE *stream, int *entropy)
return 0; return 0;
} }
static int randombytes_linux_wait_for_entropy(int device) static int randombytes_linux_wait_for_entropy(int device) {
{
/* We will block on /dev/random, because any increase in the OS' entropy /* We will block on /dev/random, because any increase in the OS' entropy
* level will unblock the request. I use poll here (as does libsodium), * level will unblock the request. I use poll here (as does libsodium),
* because we don't *actually* want to read from the device. */ * because we don't *actually* want to read from the device. */
@ -159,7 +152,8 @@ static int randombytes_linux_wait_for_entropy(int device)
struct pollfd pfd; struct pollfd pfd;
int fd; int fd;
FILE *proc_file; FILE *proc_file;
int retcode, retcode_error = 0; // Used as return codes throughout this function int retcode,
retcode_error = 0; // Used as return codes throughout this function
int entropy = 0; int entropy = 0;
/* If the device has enough entropy already, we will want to return early */ /* If the device has enough entropy already, we will want to return early */
@ -196,9 +190,11 @@ static int randombytes_linux_wait_for_entropy(int device)
continue; continue;
} else if (retcode == 1) { } else if (retcode == 1) {
if (strategy == IOCTL) { if (strategy == IOCTL) {
retcode = randombytes_linux_read_entropy_ioctl(device, &entropy); retcode =
randombytes_linux_read_entropy_ioctl(device, &entropy);
} else if (strategy == PROC) { } else if (strategy == PROC) {
retcode = randombytes_linux_read_entropy_proc(proc_file, &entropy); retcode =
randombytes_linux_read_entropy_proc(proc_file, &entropy);
} else { } else {
return -1; // Unreachable return -1; // Unreachable
} }
@ -231,17 +227,17 @@ static int randombytes_linux_wait_for_entropy(int device)
return retcode; return retcode;
} }
static int randombytes_linux_randombytes_urandom(void *buf, size_t n) {
static int randombytes_linux_randombytes_urandom(void *buf, size_t n)
{
int fd; int fd;
size_t offset = 0, count; size_t offset = 0, count;
ssize_t tmp; ssize_t tmp;
do { do {
fd = open("/dev/urandom", O_RDONLY); fd = open("/dev/urandom", O_RDONLY);
} while (fd == -1 && errno == EINTR); } while (fd == -1 && errno == EINTR);
if (fd == -1) return -1; if (fd == -1)
if (randombytes_linux_wait_for_entropy(fd) == -1) return -1; return -1;
if (randombytes_linux_wait_for_entropy(fd) == -1)
return -1;
while (n > 0) { while (n > 0) {
count = n <= SSIZE_MAX ? n : SSIZE_MAX; count = n <= SSIZE_MAX ? n : SSIZE_MAX;
@ -249,7 +245,8 @@ static int randombytes_linux_randombytes_urandom(void *buf, size_t n)
if (tmp == -1 && (errno == EAGAIN || errno == EINTR)) { if (tmp == -1 && (errno == EAGAIN || errno == EINTR)) {
continue; continue;
} }
if (tmp == -1) return -1; /* Unrecoverable IO error */ if (tmp == -1)
return -1; /* Unrecoverable IO error */
offset += tmp; offset += tmp;
n -= tmp; n -= tmp;
} }
@ -258,19 +255,17 @@ static int randombytes_linux_randombytes_urandom(void *buf, size_t n)
} }
#endif /* defined(__linux__) && !defined(SYS_getrandom) */ #endif /* defined(__linux__) && !defined(SYS_getrandom) */
#if defined(BSD) #if defined(BSD)
static int randombytes_bsd_randombytes(void *buf, size_t n) static int randombytes_bsd_randombytes(void *buf, size_t n) {
{
arc4random_buf(buf, n); arc4random_buf(buf, n);
return 0; return 0;
} }
#endif /* defined(BSD) */ #endif /* defined(BSD) */
#if defined(__EMSCRIPTEN__) #if defined(__EMSCRIPTEN__)
static int randombytes_js_randombytes_nodejs(void *buf, size_t n) { static int randombytes_js_randombytes_nodejs(void *buf, size_t n) {
const int ret = EM_ASM_INT({ const int ret = EM_ASM_INT(
{
var crypto; var crypto;
try { try {
crypto = require('crypto'); crypto = require('crypto');
@ -283,7 +278,8 @@ static int randombytes_js_randombytes_nodejs(void *buf, size_t n) {
} catch (error) { } catch (error) {
return -1; return -1;
} }
}, buf, n); },
buf, n);
switch (ret) { switch (ret) {
case 0: case 0:
return 0; return 0;
@ -298,19 +294,17 @@ static int randombytes_js_randombytes_nodejs(void *buf, size_t n) {
} }
#endif /* defined(__EMSCRIPTEN__) */ #endif /* defined(__EMSCRIPTEN__) */
int randombytes(uint8_t *buf, size_t n) {
int randombytes(uint8_t *buf, size_t n)
{
#if defined(__EMSCRIPTEN__) #if defined(__EMSCRIPTEN__)
return randombytes_js_randombytes_nodejs(buf, n); return randombytes_js_randombytes_nodejs(buf, n);
#elif defined(__linux__) #elif defined(__linux__)
# if defined(SYS_getrandom) #if defined(SYS_getrandom)
/* Use getrandom system call */ /* Use getrandom system call */
return randombytes_linux_randombytes_getrandom(buf, n); return randombytes_linux_randombytes_getrandom(buf, n);
# else #else
/* When we have enough entropy, we can read from /dev/urandom */ /* When we have enough entropy, we can read from /dev/urandom */
return randombytes_linux_randombytes_urandom(buf, n); return randombytes_linux_randombytes_urandom(buf, n);
# endif #endif
#elif defined(BSD) #elif defined(BSD)
/* Use arc4random system call */ /* Use arc4random system call */
return randombytes_bsd_randombytes(buf, n); return randombytes_bsd_randombytes(buf, n);
@ -318,6 +312,6 @@ int randombytes(uint8_t *buf, size_t n)
/* Use windows API */ /* Use windows API */
return randombytes_win32_randombytes(buf, n); return randombytes_win32_randombytes(buf, n);
#else #else
# error "randombytes(...) is not supported on this platform" #error "randombytes(...) is not supported on this platform"
#endif #endif
} }

4
common/randombytes.h
View File

@ -3,9 +3,9 @@
#include <stdint.h> #include <stdint.h>
#ifdef _WIN32 #ifdef _WIN32
# include <CRTDEFS.H> #include <CRTDEFS.H>
#else #else
# include <unistd.h> #include <unistd.h>
#endif #endif
int randombytes(uint8_t *buf, size_t xlen); int randombytes(uint8_t *buf, size_t xlen);

8
test/crypto_kem/functest.c
View File

@ -107,7 +107,9 @@ static int test_invalid_sk_a(void) {
// Alice uses Bobs response to get her secret key // Alice uses Bobs response to get her secret key
if ((returncode = crypto_kem_dec(key_a, sendb, sk_a)) > 0) { if ((returncode = crypto_kem_dec(key_a, sendb, sk_a)) > 0) {
printf("ERROR failing crypto_kem_dec returned %d instead of negative or zero code\n", returncode); printf("ERROR failing crypto_kem_dec returned %d instead of "
"negative or zero code\n",
returncode);
return -1; return -1;
} }
@ -143,7 +145,9 @@ static int test_invalid_ciphertext(void) {
// Alice uses Bobs response to get her secret key // Alice uses Bobs response to get her secret key
if ((returncode = crypto_kem_dec(key_a, sendb, sk_a)) > 0) { if ((returncode = crypto_kem_dec(key_a, sendb, sk_a)) > 0) {
printf("ERROR crypto_kem_dec should either fail (negative returncode) or succeed (return 0) but returned %d\n", returncode); printf("ERROR crypto_kem_dec should either fail (negative "
"returncode) or succeed (return 0) but returned %d\n",
returncode);
return -1; return -1;
} }

4
test/crypto_sign/functest.c
View File

@ -41,7 +41,6 @@ static int check_canary(const unsigned char *d) {
return -1; \ return -1; \
} }
static int test_sign(void) { static int test_sign(void) {
unsigned char pk[CRYPTO_PUBLICKEYBYTES + 16]; unsigned char pk[CRYPTO_PUBLICKEYBYTES + 16];
unsigned char sk[CRYPTO_SECRETKEYBYTES + 16]; unsigned char sk[CRYPTO_SECRETKEYBYTES + 16];
@ -70,7 +69,8 @@ static int test_sign(void) {
// By relying on m == sm we prevent having to allocate CRYPTO_BYTES // By relying on m == sm we prevent having to allocate CRYPTO_BYTES
// twice // twice
if ((returncode = crypto_sign_open(sm + 8, &mlen, sm + 8, smlen, pk + 8)) != 0) { if ((returncode =
crypto_sign_open(sm + 8, &mlen, sm + 8, smlen, pk + 8)) != 0) {
printf("ERROR Signature did not verify correctly!\n"); printf("ERROR Signature did not verify correctly!\n");
if (returncode > 0) { if (returncode > 0) {
puts("ERROR return code should be < 0 on failure"); puts("ERROR return code should be < 0 on failure");