Browse Source
ccan/autodata, ccan/breakpoint, ccan/crypto/hmac_sha256, ccan/crypto/hkdf_sha256, ccan/fdpass and ccan/io/fdpass. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>ppa-0.6.1
Rusty Russell
8 years ago
83 changed files with 2883 additions and 354 deletions
@ -1,3 +1,3 @@ |
|||||
CCAN imported from http://ccodearchive.net. |
CCAN imported from http://ccodearchive.net. |
||||
|
|
||||
CCAN version: init-2302-g6b74669 |
CCAN version: init-2338-g97ac583 |
||||
|
|||||
@ -0,0 +1 @@ |
|||||
|
../../licenses/BSD-MIT |
||||
@ -0,0 +1,111 @@ |
|||||
|
#include "config.h" |
||||
|
#include <stdio.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
/** |
||||
|
* autodata - stash pointers in your binary for automatic registration |
||||
|
* |
||||
|
* This code allows declarations in your source which you can gather |
||||
|
* together at runtime to form tables. This is often used in place of |
||||
|
* having a central registration function or table. |
||||
|
* |
||||
|
* Note that this technique does not work in general for shared libaries, |
||||
|
* only for code compiled into a binary. |
||||
|
* |
||||
|
* License: BSD-MIT |
||||
|
* |
||||
|
* Example: |
||||
|
* // Distributed commandline option registration (note: ccan/opt is better!) |
||||
|
* #include <ccan/autodata/autodata.h> |
||||
|
* #include <stdio.h> |
||||
|
* #include <unistd.h> |
||||
|
* #include <stdbool.h> |
||||
|
* #include <err.h> |
||||
|
* |
||||
|
* static bool verbose = false; |
||||
|
* |
||||
|
* // This would normally be in a header, so any C file can use it. |
||||
|
* struct option { |
||||
|
* char c; |
||||
|
* bool takes_arg; |
||||
|
* bool (*cb)(char *optarg); |
||||
|
* }; |
||||
|
* AUTODATA_TYPE(options, struct option); |
||||
|
* #define REGISTER_OPTION(optstruct) \ |
||||
|
* AUTODATA(options, (optstruct)) |
||||
|
* |
||||
|
* // Now a few examples (could be anywhere in source) |
||||
|
* static bool verbose_cb(char *unused) |
||||
|
* { |
||||
|
* verbose = true; |
||||
|
* return true; |
||||
|
* } |
||||
|
* static struct option dash_v = { 'v', false, verbose_cb }; |
||||
|
* REGISTER_OPTION(&dash_v); |
||||
|
* |
||||
|
* static bool chdir_cb(char *dir) |
||||
|
* { |
||||
|
* if (verbose) |
||||
|
* printf("chdir to %s. ", dir); |
||||
|
* if (chdir(dir) != 0) |
||||
|
* return false; |
||||
|
* return true; |
||||
|
* } |
||||
|
* static struct option dash_C = { 'C', true, chdir_cb }; |
||||
|
* REGISTER_OPTION(&dash_C); |
||||
|
* |
||||
|
* int main(int argc, char *argv[]) |
||||
|
* { |
||||
|
* struct option **opts; |
||||
|
* size_t i, num; |
||||
|
* int o; |
||||
|
* char *optstring, *p; |
||||
|
* |
||||
|
* // Gather together all the registered options. |
||||
|
* opts = autodata_get(options, &num); |
||||
|
* |
||||
|
* // Make pretty string for getopt(). |
||||
|
* p = optstring = malloc(num * 2 + 1); |
||||
|
* for (i = 0; i < num; i++) { |
||||
|
* *(p++) = opts[i]->c; |
||||
|
* if (opts[i]->takes_arg) |
||||
|
* *(p++) = ':'; |
||||
|
* } |
||||
|
* *p = '\0'; |
||||
|
* |
||||
|
* while ((o = getopt(argc, argv, optstring)) != -1) { |
||||
|
* if (o == '?') |
||||
|
* exit(1); |
||||
|
* // Call callback in matching option. |
||||
|
* for (i = 0; i < num; i++) { |
||||
|
* if (opts[i]->c == o) { |
||||
|
* if (!opts[i]->cb(optarg)) |
||||
|
* err(1, "parsing -%c", o); |
||||
|
* break; |
||||
|
* } |
||||
|
* } |
||||
|
* } |
||||
|
* // free up gathered option table. |
||||
|
* autodata_free(opts); |
||||
|
* |
||||
|
* if (verbose) |
||||
|
* printf("verbose mode on\n"); |
||||
|
* return 0; |
||||
|
* } |
||||
|
* // Given "-v" outputs "verbose mode on\n" |
||||
|
* // Given "-v -C /" outputs "chdir to /. verbose mode on\n" |
||||
|
*/ |
||||
|
int main(int argc, char *argv[]) |
||||
|
{ |
||||
|
/* Expect exactly one argument */ |
||||
|
if (argc != 2) |
||||
|
return 1; |
||||
|
|
||||
|
if (strcmp(argv[1], "depends") == 0) { |
||||
|
printf("ccan/compiler\n"); |
||||
|
printf("ccan/ptr_valid\n"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
return 1; |
||||
|
} |
||||
@ -0,0 +1,80 @@ |
|||||
|
// Licensed under BSD-MIT: See LICENSE.
|
||||
|
#include "autodata.h" |
||||
|
#include <stdint.h> |
||||
|
#include <unistd.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
#if HAVE_SECTION_START_STOP |
||||
|
void *autodata_get_section(void *start, void *stop, size_t *nump) |
||||
|
{ |
||||
|
*nump = (void **)(stop) - (void **)(start); |
||||
|
return start; |
||||
|
} |
||||
|
|
||||
|
void autodata_free(void *table UNNEEDED) |
||||
|
{ |
||||
|
} |
||||
|
#else |
||||
|
#include <ccan/ptr_valid/ptr_valid.h> |
||||
|
|
||||
|
void *autodata_make_table(const void *example, const char *name, size_t *nump) |
||||
|
{ |
||||
|
const char *start, *end, *tag; |
||||
|
struct ptr_valid_batch batch; |
||||
|
const void *const magic = (void *)AUTODATA_MAGIC; |
||||
|
void **table = NULL; |
||||
|
char first_magic; |
||||
|
|
||||
|
if (!ptr_valid_batch_start(&batch)) |
||||
|
return NULL; |
||||
|
|
||||
|
/* Get range to search. */ |
||||
|
for (start = (char *)((intptr_t)example & ~(getpagesize() - 1)); |
||||
|
ptr_valid_batch(&batch, start-getpagesize(), 1, sizeof(void *), |
||||
|
false); |
||||
|
start -= getpagesize()); |
||||
|
|
||||
|
for (end = (char *)((intptr_t)example & ~(getpagesize() - 1)); |
||||
|
ptr_valid_batch(&batch, end, 1, sizeof(void *), false); |
||||
|
end += getpagesize()); |
||||
|
|
||||
|
*nump = 0; |
||||
|
first_magic = *(char *)&magic; |
||||
|
for (tag = memchr(start, first_magic, end - start); |
||||
|
tag; |
||||
|
tag = memchr(tag+1, first_magic, end - (tag + 1))) { |
||||
|
void *adata[4]; |
||||
|
|
||||
|
/* We can read 4 void *'s here? */ |
||||
|
if (tag + sizeof(adata) > end) |
||||
|
continue; |
||||
|
|
||||
|
memcpy(adata, tag, sizeof(adata)); |
||||
|
|
||||
|
/* False match? */ |
||||
|
if (adata[0] != (void *)AUTODATA_MAGIC || adata[1] != tag) |
||||
|
continue; |
||||
|
|
||||
|
/* OK, check name. */ |
||||
|
if (!ptr_valid_batch_string(&batch, adata[3]) |
||||
|
|| strcmp(name, adata[3]) != 0) |
||||
|
continue; |
||||
|
|
||||
|
if (!ptr_valid_batch_read(&batch, (char *)adata[2])) |
||||
|
continue; |
||||
|
|
||||
|
table = realloc(table, sizeof(void *) * (*nump + 1)); |
||||
|
if (!table) |
||||
|
break; |
||||
|
table[*nump] = adata[2]; |
||||
|
(*nump)++; |
||||
|
} |
||||
|
ptr_valid_batch_end(&batch); |
||||
|
return table; |
||||
|
} |
||||
|
|
||||
|
void autodata_free(void *table) |
||||
|
{ |
||||
|
free(table); |
||||
|
} |
||||
|
#endif |
||||
@ -0,0 +1,109 @@ |
|||||
|
// Licensed under BSD-MIT: See LICENSE.
|
||||
|
#ifndef CCAN_AUTODATA_H |
||||
|
#define CCAN_AUTODATA_H |
||||
|
#include "config.h" |
||||
|
#include <ccan/compiler/compiler.h> |
||||
|
#include <stdlib.h> |
||||
|
|
||||
|
#if HAVE_SECTION_START_STOP |
||||
|
|
||||
|
/**
|
||||
|
* AUTODATA_TYPE - declare the type for a given autodata name. |
||||
|
* @name: the name for this set of autodata |
||||
|
* @type: the type this autodata points to |
||||
|
* |
||||
|
* This macro is usually placed in a header: it must preceed any |
||||
|
* autodata functions in the file. |
||||
|
* |
||||
|
* Example: |
||||
|
* #include <ccan/autodata/autodata.h> |
||||
|
* |
||||
|
* // My set of char pointers.
|
||||
|
* AUTODATA_TYPE(names, char); |
||||
|
*/ |
||||
|
#define AUTODATA_TYPE(name, type) \ |
||||
|
typedef type autodata_##name##_; \ |
||||
|
extern type *__start_xautodata_##name[], *__stop_xautodata_##name[] |
||||
|
|
||||
|
/**
|
||||
|
* AUTODATA - add a pointer to this autodata set |
||||
|
* @name: the name of the set of autodata |
||||
|
* @ptr: the compile-time-known pointer |
||||
|
* |
||||
|
* This embeds @ptr into the binary, with the tag corresponding to |
||||
|
* @name (which must look like a valid identifier, no punctuation!). |
||||
|
* The type of @ptr must match that given by AUTODATA_TYPE. It is |
||||
|
* usually a file-level declaration. |
||||
|
* |
||||
|
* Example: |
||||
|
* // Put two char pointers into the names AUTODATA set.
|
||||
|
* AUTODATA(names, "Arabella"); |
||||
|
* AUTODATA(names, "Alex"); |
||||
|
*/ |
||||
|
#define AUTODATA(name, ptr) \ |
||||
|
static const autodata_##name##_ *NEEDED \ |
||||
|
__attribute__((section("xautodata_" #name))) \ |
||||
|
AUTODATA_VAR_(name, __LINE__) = (ptr); |
||||
|
|
||||
|
/**
|
||||
|
* autodata_get - get an autodata set |
||||
|
* @name: the name of the set of autodata |
||||
|
* @nump: the number of items in the set. |
||||
|
* |
||||
|
* This extract the embedded pointers matching @name. It may fail |
||||
|
* if malloc() fails, or if there is no AUTODATA at all. |
||||
|
* |
||||
|
* The return will be a pointer to an array of @type pointers (from |
||||
|
* AUTODATA_TYPE). |
||||
|
* |
||||
|
* Example: |
||||
|
* static void print_embedded_names(void) |
||||
|
* { |
||||
|
* unsigned int i; |
||||
|
* size_t num; |
||||
|
* char **n = autodata_get(names, &num); |
||||
|
* |
||||
|
* for (i = 0; i < num; i++) |
||||
|
* printf("%s\n", n[i]); |
||||
|
* } |
||||
|
*/ |
||||
|
#define autodata_get(name, nump) \ |
||||
|
((autodata_##name##_ **) \ |
||||
|
autodata_get_section(__start_xautodata_##name, \ |
||||
|
__stop_xautodata_##name, (nump))) |
||||
|
#endif /* HAVE_SECTION_START_STOP */ |
||||
|
|
||||
|
/**
|
||||
|
* autodata_free - free the table returned by autodata_get() |
||||
|
* @p: the table. |
||||
|
*/ |
||||
|
void autodata_free(void *p); |
||||
|
|
||||
|
/* Internal functions. */ |
||||
|
#define AUTODATA_VAR__(name, line) autodata_##name##_##line |
||||
|
#define AUTODATA_VAR_(name, line) AUTODATA_VAR__(name, line) |
||||
|
|
||||
|
#if HAVE_SECTION_START_STOP |
||||
|
void *autodata_get_section(void *start, void *stop, size_t *nump); |
||||
|
#else |
||||
|
#define AUTODATA_TYPE(name, type) \ |
||||
|
typedef type autodata_##name##_; \ |
||||
|
static const void *autodata_##name##_ex = &autodata_##name##_ex |
||||
|
|
||||
|
#define AUTODATA_MAGIC ((long)0xFEEDA10DA7AF00D5ULL) |
||||
|
#define AUTODATA(name, ptr) \ |
||||
|
static const autodata_##name##_ *NEEDED \ |
||||
|
AUTODATA_VAR_(name, __LINE__)[4] = \ |
||||
|
{ (void *)AUTODATA_MAGIC, \ |
||||
|
(void *)&AUTODATA_VAR_(name, __LINE__), \ |
||||
|
(ptr), \ |
||||
|
(void *)#name } |
||||
|
|
||||
|
#define autodata_get(name, nump) \ |
||||
|
((autodata_##name##_ **) \ |
||||
|
autodata_make_table(&autodata_##name##_ex, #name, (nump))) |
||||
|
|
||||
|
void *autodata_make_table(const void *example, const char *name, size_t *nump); |
||||
|
#endif |
||||
|
|
||||
|
#endif /* CCAN_AUTODATA_H */ |
||||
@ -0,0 +1,6 @@ |
|||||
|
/* Check that linking together works. */ |
||||
|
#include <ccan/autodata/autodata.h> |
||||
|
|
||||
|
AUTODATA_TYPE(autostrings, char); |
||||
|
|
||||
|
AUTODATA(autostrings, "helper"); |
||||
@ -0,0 +1,71 @@ |
|||||
|
#include <ccan/autodata/autodata.h> |
||||
|
/* Include the C files directly. */ |
||||
|
#include <ccan/autodata/autodata.c> |
||||
|
#include <ccan/tap/tap.h> |
||||
|
|
||||
|
AUTODATA_TYPE(autostrings, char); |
||||
|
|
||||
|
AUTODATA(autostrings, "genuine"); |
||||
|
|
||||
|
#if !HAVE_SECTION_START_STOP |
||||
|
/* These are all fake, to test the various failure paths. */ |
||||
|
/* Hopefully fake_alpha or fake_omega will test run-past-end. */ |
||||
|
static const void *NEEDED fake_alpha[] = { (void *)AUTODATA_MAGIC }; |
||||
|
|
||||
|
/* Wrong magic in the middle. */ |
||||
|
static const void *NEEDED fake1[] = { (void *)(AUTODATA_MAGIC ^ 0x10000), |
||||
|
(void *)&fake1, |
||||
|
"fake1", |
||||
|
(void *)"autostrings" }; |
||||
|
|
||||
|
/* Wrong self pointer. */ |
||||
|
static const void *NEEDED fake2[] = { (void *)AUTODATA_MAGIC, |
||||
|
(void *)&fake1, |
||||
|
"fake2", |
||||
|
(void *)"autostrings" }; |
||||
|
|
||||
|
/* Wrong name. */ |
||||
|
static const void *NEEDED fake3[] = { (void *)AUTODATA_MAGIC, |
||||
|
(void *)&fake3, |
||||
|
"fake3", |
||||
|
(void *)"autostrings2" }; |
||||
|
|
||||
|
/* Invalid self-pointer. */ |
||||
|
static const void *NEEDED fake4[] = { (void *)AUTODATA_MAGIC, |
||||
|
(void *)1UL, |
||||
|
"fake4", |
||||
|
(void *)"autostrings" }; |
||||
|
|
||||
|
/* Invalid name pointer */ |
||||
|
static const void *NEEDED fake5[] = { (void *)AUTODATA_MAGIC, |
||||
|
(void *)&fake5, |
||||
|
"fake5", |
||||
|
(void *)1UL }; |
||||
|
|
||||
|
/* Invalid contents pointer */ |
||||
|
static const void *NEEDED fake6[] = { (void *)AUTODATA_MAGIC, |
||||
|
(void *)&fake6, |
||||
|
(char *)1UL, |
||||
|
(void *)"autostrings" }; |
||||
|
|
||||
|
static const void *NEEDED fake_omega[] = { (void *)AUTODATA_MAGIC }; |
||||
|
#endif |
||||
|
|
||||
|
int main(void) |
||||
|
{ |
||||
|
char **table; |
||||
|
size_t num; |
||||
|
|
||||
|
/* This is how many tests you plan to run */ |
||||
|
plan_tests(2); |
||||
|
|
||||
|
table = autodata_get(autostrings, &num); |
||||
|
ok1(num == 2); |
||||
|
ok1((!strcmp(table[0], "genuine") && !strcmp(table[1], "helper")) |
||||
|
|| (!strcmp(table[1], "genuine") && !strcmp(table[0], "helper"))); |
||||
|
|
||||
|
autodata_free(table); |
||||
|
|
||||
|
/* This exits depending on whether all tests passed */ |
||||
|
return exit_status(); |
||||
|
} |
||||
@ -0,0 +1,41 @@ |
|||||
|
#include <ccan/autodata/autodata.h> |
||||
|
/* Include the C files directly. */ |
||||
|
#include <ccan/autodata/autodata.c> |
||||
|
#include <ccan/tap/tap.h> |
||||
|
|
||||
|
AUTODATA_TYPE(autostrings, char); |
||||
|
|
||||
|
AUTODATA(autostrings, "hello"); |
||||
|
AUTODATA(autostrings, "world"); |
||||
|
|
||||
|
int main(void) |
||||
|
{ |
||||
|
char **table; |
||||
|
size_t num; |
||||
|
int i, hello = -1, world = -1, helper = -1; |
||||
|
|
||||
|
/* This is how many tests you plan to run */ |
||||
|
plan_tests(4); |
||||
|
|
||||
|
table = autodata_get(autostrings, &num); |
||||
|
ok1(num == 3); |
||||
|
|
||||
|
for (i = 0; i < num; i++) { |
||||
|
if (strcmp(table[i], "hello") == 0) |
||||
|
hello = i; |
||||
|
else if (strcmp(table[i], "world") == 0) |
||||
|
world = i; |
||||
|
else if (strcmp(table[i], "helper") == 0) |
||||
|
helper = i; |
||||
|
else |
||||
|
fail("Unknown entry %s", table[i]); |
||||
|
} |
||||
|
ok1(hello != -1); |
||||
|
ok1(world != -1); |
||||
|
ok1(helper != -1); |
||||
|
|
||||
|
autodata_free(table); |
||||
|
|
||||
|
/* This exits depending on whether all tests passed */ |
||||
|
return exit_status(); |
||||
|
} |
||||
@ -0,0 +1 @@ |
|||||
|
../../licenses/CC0 |
||||
@ -0,0 +1,34 @@ |
|||||
|
#include "config.h" |
||||
|
#include <stdio.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
/** |
||||
|
* breakpoint - break if the program is run under gdb. |
||||
|
* |
||||
|
* This code allows you to insert breakpoints within a program. These will |
||||
|
* do nothing unless your program is run under GDB. |
||||
|
* |
||||
|
* License: CC0 (Public domain) |
||||
|
* |
||||
|
* Example: |
||||
|
* #include <ccan/breakpoint/breakpoint.h> |
||||
|
* |
||||
|
* int main(void) |
||||
|
* { |
||||
|
* breakpoint(); |
||||
|
* return 0; |
||||
|
* } |
||||
|
*/ |
||||
|
int main(int argc, char *argv[]) |
||||
|
{ |
||||
|
/* Expect exactly one argument */ |
||||
|
if (argc != 2) |
||||
|
return 1; |
||||
|
|
||||
|
if (strcmp(argv[1], "depends") == 0) { |
||||
|
printf("ccan/compiler\n"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
return 1; |
||||
|
} |
||||
@ -0,0 +1,32 @@ |
|||||
|
/* CC0 (Public domain) - see LICENSE file for details
|
||||
|
* |
||||
|
* Idea for implementation thanks to stackoverflow.com: |
||||
|
* http://stackoverflow.com/questions/3596781/detect-if-gdb-is-running
|
||||
|
*/ |
||||
|
#include <ccan/breakpoint/breakpoint.h> |
||||
|
|
||||
|
bool breakpoint_initialized; |
||||
|
bool breakpoint_under_debug; |
||||
|
|
||||
|
/* This doesn't get called if we're under GDB. */ |
||||
|
static void trap(int signum) |
||||
|
{ |
||||
|
breakpoint_initialized = true; |
||||
|
} |
||||
|
|
||||
|
void breakpoint_init(void) |
||||
|
{ |
||||
|
struct sigaction old, new; |
||||
|
|
||||
|
new.sa_handler = trap; |
||||
|
new.sa_flags = 0; |
||||
|
sigemptyset(&new.sa_mask); |
||||
|
sigaction(SIGTRAP, &new, &old); |
||||
|
kill(getpid(), SIGTRAP); |
||||
|
sigaction(SIGTRAP, &old, NULL); |
||||
|
|
||||
|
if (!breakpoint_initialized) { |
||||
|
breakpoint_initialized = true; |
||||
|
breakpoint_under_debug = true; |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,24 @@ |
|||||
|
/* CC0 (Public domain) - see LICENSE file for details */ |
||||
|
#ifndef CCAN_BREAKPOINT_H |
||||
|
#define CCAN_BREAKPOINT_H |
||||
|
#include <ccan/compiler/compiler.h> |
||||
|
#include <sys/types.h> |
||||
|
#include <unistd.h> |
||||
|
#include <signal.h> |
||||
|
#include <stdbool.h> |
||||
|
|
||||
|
void breakpoint_init(void) COLD; |
||||
|
extern bool breakpoint_initialized; |
||||
|
extern bool breakpoint_under_debug; |
||||
|
|
||||
|
/**
|
||||
|
* breakpoint - stop if running under the debugger. |
||||
|
*/ |
||||
|
static inline void breakpoint(void) |
||||
|
{ |
||||
|
if (!breakpoint_initialized) |
||||
|
breakpoint_init(); |
||||
|
if (breakpoint_under_debug) |
||||
|
kill(getpid(), SIGTRAP); |
||||
|
} |
||||
|
#endif /* CCAN_BREAKPOINT_H */ |
||||
@ -0,0 +1,17 @@ |
|||||
|
#include <ccan/breakpoint/breakpoint.h> |
||||
|
#include <ccan/breakpoint/breakpoint.c> |
||||
|
#include <ccan/tap/tap.h> |
||||
|
|
||||
|
int main(void) |
||||
|
{ |
||||
|
/* This is how many tests you plan to run */ |
||||
|
plan_tests(2); |
||||
|
|
||||
|
breakpoint(); |
||||
|
|
||||
|
ok1(breakpoint_initialized); |
||||
|
ok1(!breakpoint_under_debug); |
||||
|
|
||||
|
/* This exits depending on whether all tests passed */ |
||||
|
return exit_status(); |
||||
|
} |
||||
@ -0,0 +1 @@ |
|||||
|
../../../licenses/BSD-MIT |
||||
@ -0,0 +1,30 @@ |
|||||
|
#include "config.h" |
||||
|
#include <stdio.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
/** |
||||
|
* crypto/hkdf_sha256 - RFC5869 Hardened Key Derivation Functions using SHA256 |
||||
|
* |
||||
|
* This code implements the hkdf described in RFC5869. |
||||
|
* |
||||
|
* License: BSD-MIT |
||||
|
* Maintainer: Rusty Russell <rusty@rustcorp.com.au> |
||||
|
*/ |
||||
|
int main(int argc, char *argv[]) |
||||
|
{ |
||||
|
/* Expect exactly one argument */ |
||||
|
if (argc != 2) |
||||
|
return 1; |
||||
|
|
||||
|
if (strcmp(argv[1], "depends") == 0) { |
||||
|
printf("ccan/crypto/hmac_sha256\n"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
if (strcmp(argv[1], "testdepends") == 0) { |
||||
|
printf("ccan/str/hex\n"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
return 1; |
||||
|
} |
||||
@ -0,0 +1,97 @@ |
|||||
|
/* MIT (BSD) license - see LICENSE file for details */ |
||||
|
#include <ccan/crypto/hkdf_sha256/hkdf_sha256.h> |
||||
|
#include <ccan/crypto/hmac_sha256/hmac_sha256.h> |
||||
|
#include <assert.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
void hkdf_sha256(void *okm, size_t okm_size, |
||||
|
const void *s, size_t ssize, |
||||
|
const void *k, size_t ksize, |
||||
|
const void *info, size_t isize) |
||||
|
{ |
||||
|
struct hmac_sha256 prk, t; |
||||
|
struct hmac_sha256_ctx ctx; |
||||
|
unsigned char c; |
||||
|
|
||||
|
assert(okm_size < 255 * sizeof(t)); |
||||
|
|
||||
|
/* RFC 5869:
|
||||
|
* |
||||
|
* 2.2. Step 1: Extract |
||||
|
* |
||||
|
* HKDF-Extract(salt, IKM) -> PRK |
||||
|
* |
||||
|
* Options: |
||||
|
* Hash a hash function; HashLen denotes the length of the |
||||
|
* hash function output in octets |
||||
|
* |
||||
|
* Inputs: |
||||
|
* salt optional salt value (a non-secret random value); |
||||
|
* if not provided, it is set to a string of HashLen zeros. |
||||
|
* IKM input keying material |
||||
|
* |
||||
|
* Output: |
||||
|
* PRK a pseudorandom key (of HashLen octets) |
||||
|
* |
||||
|
* The output PRK is calculated as follows: |
||||
|
* |
||||
|
* PRK = HMAC-Hash(salt, IKM) |
||||
|
*/ |
||||
|
hmac_sha256(&prk, s, ssize, k, ksize); |
||||
|
|
||||
|
/*
|
||||
|
* 2.3. Step 2: Expand |
||||
|
* |
||||
|
* HKDF-Expand(PRK, info, L) -> OKM |
||||
|
* |
||||
|
* Options: |
||||
|
* Hash a hash function; HashLen denotes the length of the |
||||
|
* hash function output in octets |
||||
|
* |
||||
|
* Inputs: |
||||
|
* PRK a pseudorandom key of at least HashLen octets |
||||
|
* (usually, the output from the extract step) |
||||
|
* info optional context and application specific information |
||||
|
* (can be a zero-length string) |
||||
|
* L length of output keying material in octets |
||||
|
* (<= 255*HashLen) |
||||
|
* |
||||
|
* Output: |
||||
|
* OKM output keying material (of L octets) |
||||
|
* |
||||
|
* The output OKM is calculated as follows: |
||||
|
* |
||||
|
* N = ceil(L/HashLen) |
||||
|
* T = T(1) | T(2) | T(3) | ... | T(N) |
||||
|
* OKM = first L octets of T |
||||
|
* |
||||
|
* where: |
||||
|
* T(0) = empty string (zero length) |
||||
|
* T(1) = HMAC-Hash(PRK, T(0) | info | 0x01) |
||||
|
* T(2) = HMAC-Hash(PRK, T(1) | info | 0x02) |
||||
|
* T(3) = HMAC-Hash(PRK, T(2) | info | 0x03) |
||||
|
* ... |
||||
|
* |
||||
|
* (where the constant concatenated to the end of each T(n) is a |
||||
|
* single octet.) |
||||
|
*/ |
||||
|
c = 1; |
||||
|
hmac_sha256_init(&ctx, &prk, sizeof(prk)); |
||||
|
hmac_sha256_update(&ctx, info, isize); |
||||
|
hmac_sha256_update(&ctx, &c, 1); |
||||
|
hmac_sha256_done(&ctx, &t); |
||||
|
|
||||
|
while (okm_size > sizeof(t)) { |
||||
|
memcpy(okm, &t, sizeof(t)); |
||||
|
okm = (char *)okm + sizeof(t); |
||||
|
okm_size -= sizeof(t); |
||||
|
|
||||
|
c++; |
||||
|
hmac_sha256_init(&ctx, &prk, sizeof(prk)); |
||||
|
hmac_sha256_update(&ctx, &t, sizeof(t)); |
||||
|
hmac_sha256_update(&ctx, info, isize); |
||||
|
hmac_sha256_update(&ctx, &c, 1); |
||||
|
hmac_sha256_done(&ctx, &t); |
||||
|
} |
||||
|
memcpy(okm, &t, okm_size); |
||||
|
} |
||||
@ -0,0 +1,22 @@ |
|||||
|
#ifndef CCAN_CRYPTO_HKDF_SHA256_H |
||||
|
#define CCAN_CRYPTO_HKDF_SHA256_H |
||||
|
/* BSD-MIT - see LICENSE file for details */ |
||||
|
#include "config.h" |
||||
|
#include <stdlib.h> |
||||
|
|
||||
|
/**
|
||||
|
* hkdf_sha256 - generate a derived key |
||||
|
* @okm: where to output the key |
||||
|
* @okm_size: the number of bytes pointed to by @okm (must be less than 255*32) |
||||
|
* @s: salt |
||||
|
* @ssize: the number of bytes pointed to by @s |
||||
|
* @k: pointer to input key |
||||
|
* @ksize: the number of bytes pointed to by @k |
||||
|
* @info: pointer to info |
||||
|
* @isize: the number of bytes pointed to by @info |
||||
|
*/ |
||||
|
void hkdf_sha256(void *okm, size_t okm_size, |
||||
|
const void *s, size_t ssize, |
||||
|
const void *k, size_t ksize, |
||||
|
const void *info, size_t isize); |
||||
|
#endif /* CCAN_CRYPTO_HKDF_SHA256_H */ |
||||
@ -0,0 +1,101 @@ |
|||||
|
/* From RFC5869 Appendix A
|
||||
|
* |
||||
|
* https://tools.ietf.org/html/rfc5869
|
||||
|
*/ |
||||
|
#include <ccan/crypto/hkdf_sha256/hkdf_sha256.h> |
||||
|
#include <ccan/tap/tap.h> |
||||
|
#include <ccan/str/hex/hex.h> |
||||
|
#include <string.h> |
||||
|
#include <assert.h> |
||||
|
|
||||
|
struct test { |
||||
|
const char *ikm, *salt, *info, *okm; |
||||
|
}; |
||||
|
|
||||
|
static struct test tests[] = { { |
||||
|
/* Test Case 1
|
||||
|
Basic test case with SHA-256 |
||||
|
*/ |
||||
|
"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", /* (22 octets) */ |
||||
|
"000102030405060708090a0b0c", /* (13 octets) */ |
||||
|
"f0f1f2f3f4f5f6f7f8f9", /* (10 octets) */ |
||||
|
"3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865", /* (42 octets) */ |
||||
|
}, |
||||
|
{ |
||||
|
/* Test Case 2
|
||||
|
* |
||||
|
* Test with SHA-256 and longer inputs/outputs */ |
||||
|
"000102030405060708090a0b0c0d0e0f" |
||||
|
"101112131415161718191a1b1c1d1e1f" |
||||
|
"202122232425262728292a2b2c2d2e2f" |
||||
|
"303132333435363738393a3b3c3d3e3f" |
||||
|
"404142434445464748494a4b4c4d4e4f", /* (80 octets) */ |
||||
|
"606162636465666768696a6b6c6d6e6f" |
||||
|
"707172737475767778797a7b7c7d7e7f" |
||||
|
"808182838485868788898a8b8c8d8e8f" |
||||
|
"909192939495969798999a9b9c9d9e9f" |
||||
|
"a0a1a2a3a4a5a6a7a8a9aaabacadaeaf", /* (80 octets )*/ |
||||
|
"b0b1b2b3b4b5b6b7b8b9babbbcbdbebf" |
||||
|
"c0c1c2c3c4c5c6c7c8c9cacbcccdcecf" |
||||
|
"d0d1d2d3d4d5d6d7d8d9dadbdcdddedf" |
||||
|
"e0e1e2e3e4e5e6e7e8e9eaebecedeeef" |
||||
|
"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", /* (80 octets) */ |
||||
|
"b11e398dc80327a1c8e7f78c596a4934" |
||||
|
"4f012eda2d4efad8a050cc4c19afa97c" |
||||
|
"59045a99cac7827271cb41c65e590e09" |
||||
|
"da3275600c2f09b8367793a9aca3db71" |
||||
|
"cc30c58179ec3e87c14c01d5c1f3434f" |
||||
|
"1d87" /* (82 octets) */ |
||||
|
}, |
||||
|
{ |
||||
|
/* Test Case 3
|
||||
|
* |
||||
|
* Test with SHA-256 and zero-length salt/info |
||||
|
*/ |
||||
|
"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", /* (22 octets) */ |
||||
|
"", /* (0 octets) */ |
||||
|
"", /* (0 octets) */ |
||||
|
"8da4e775a563c18f715f802a063c5a31" |
||||
|
"b8a11f5c5ee1879ec3454e5f3c738d2d" |
||||
|
"9d201395faa4b61a96c8" /* (42 octets) */ |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
static void *fromhex(const char *str, size_t *len) |
||||
|
{ |
||||
|
void *p; |
||||
|
|
||||
|
*len = hex_data_size(strlen(str)); |
||||
|
p = malloc(*len); |
||||
|
if (!hex_decode(str, strlen(str), p, *len)) |
||||
|
abort(); |
||||
|
return p; |
||||
|
} |
||||
|
|
||||
|
int main(void) |
||||
|
{ |
||||
|
size_t i; |
||||
|
|
||||
|
plan_tests(sizeof(tests) / sizeof(tests[0])); |
||||
|
|
||||
|
for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) { |
||||
|
size_t ksize, ssize, isize, okmsize; |
||||
|
void *k, *s, *info, *expect, *okm; |
||||
|
|
||||
|
k = fromhex(tests[i].ikm, &ksize); |
||||
|
s = fromhex(tests[i].salt, &ssize); |
||||
|
info = fromhex(tests[i].info, &isize); |
||||
|
expect = fromhex(tests[i].okm, &okmsize); |
||||
|
okm = malloc(okmsize); |
||||
|
hkdf_sha256(okm, okmsize, s, ssize, k, ksize, info, isize); |
||||
|
ok1(memcmp(okm, expect, okmsize) == 0); |
||||
|
|
||||
|
free(k); |
||||
|
free(s); |
||||
|
free(info); |
||||
|
free(expect); |
||||
|
free(okm); |
||||
|
} |
||||
|
|
||||
|
return exit_status(); |
||||
|
} |
||||
@ -0,0 +1 @@ |
|||||
|
../../../licenses/BSD-MIT |
||||
@ -0,0 +1,52 @@ |
|||||
|
#include "config.h" |
||||
|
#include <stdio.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
/** |
||||
|
* crypto/hmac_sha256 - RFC2104 HMAC using SHA256. |
||||
|
* |
||||
|
* This code implements RFC2104, which is a fairly standard HMAC. |
||||
|
* |
||||
|
* License: BSD-MIT |
||||
|
* Maintainer: Rusty Russell <rusty@rustcorp.com.au> |
||||
|
* |
||||
|
* Example: |
||||
|
* #include <ccan/crypto/hmac_sha256/hmac_sha256.h> |
||||
|
* #include <err.h> |
||||
|
* #include <stdio.h> |
||||
|
* #include <string.h> |
||||
|
* |
||||
|
* // Simple demonstration: idential strings will have the same hash, but |
||||
|
* // two different strings will not. |
||||
|
* int main(int argc, char *argv[]) |
||||
|
* { |
||||
|
* struct hmac_sha256 hash1, hash2; |
||||
|
* |
||||
|
* if (argc != 3) |
||||
|
* errx(1, "Usage: %s <string1> <string2>", argv[0]); |
||||
|
* |
||||
|
* hmac_sha256(&hash1, "key", 3, argv[1], strlen(argv[1])); |
||||
|
* hmac_sha256(&hash2, "key", 3, argv[2], strlen(argv[2])); |
||||
|
* printf("Hash is %s\n", memcmp(&hash1, &hash2, sizeof(hash1)) |
||||
|
* ? "different" : "same"); |
||||
|
* return 0; |
||||
|
* } |
||||
|
*/ |
||||
|
int main(int argc, char *argv[]) |
||||
|
{ |
||||
|
/* Expect exactly one argument */ |
||||
|
if (argc != 2) |
||||
|
return 1; |
||||
|
|
||||
|
if (strcmp(argv[1], "depends") == 0) { |
||||
|
printf("ccan/crypto/sha256\n"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
if (strcmp(argv[1], "testdepends") == 0) { |
||||
|
printf("ccan/str/hex\n"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
return 1; |
||||
|
} |
||||
@ -0,0 +1,160 @@ |
|||||
|
/* MIT (BSD) license - see LICENSE file for details */ |
||||
|
#include <ccan/crypto/hmac_sha256/hmac_sha256.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
#define IPAD 0x3636363636363636ULL |
||||
|
#define OPAD 0x5C5C5C5C5C5C5C5CULL |
||||
|
|
||||
|
#define BLOCK_U64S (HMAC_SHA256_BLOCKSIZE / sizeof(uint64_t)) |
||||
|
|
||||
|
static inline void xor_block(uint64_t block[BLOCK_U64S], uint64_t pad) |
||||
|
{ |
||||
|
size_t i; |
||||
|
|
||||
|
for (i = 0; i < BLOCK_U64S; i++) |
||||
|
block[i] ^= pad; |
||||
|
} |
||||
|
|
||||
|
void hmac_sha256_init(struct hmac_sha256_ctx *ctx, |
||||
|
const void *k, size_t ksize) |
||||
|
{ |
||||
|
struct sha256 hashed_key; |
||||
|
/* We use k_opad as k_ipad temporarily. */ |
||||
|
uint64_t *k_ipad = ctx->k_opad; |
||||
|
|
||||
|
/* (keys longer than B bytes are first hashed using H) */ |
||||
|
if (ksize > HMAC_SHA256_BLOCKSIZE) { |
||||
|
sha256(&hashed_key, k, ksize); |
||||
|
k = &hashed_key; |
||||
|
ksize = sizeof(hashed_key); |
||||
|
} |
||||
|
|
||||
|
/* From RFC2104:
|
||||
|
* |
||||
|
* (1) append zeros to the end of K to create a B byte string |
||||
|
* (e.g., if K is of length 20 bytes and B=64, then K will be |
||||
|
* appended with 44 zero bytes 0x00) |
||||
|
*/ |
||||
|
memcpy(k_ipad, k, ksize); |
||||
|
memset((char *)k_ipad + ksize, 0, HMAC_SHA256_BLOCKSIZE - ksize); |
||||
|
|
||||
|
/*
|
||||
|
* (2) XOR (bitwise exclusive-OR) the B byte string computed |
||||
|
* in step (1) with ipad |
||||
|
*/ |
||||
|
xor_block(k_ipad, IPAD); |
||||
|
|
||||
|
/*
|
||||
|
* We start (4) here, appending text later: |
||||
|
* |
||||
|
* (3) append the stream of data 'text' to the B byte string resulting |
||||
|
* from step (2) |
||||
|
* (4) apply H to the stream generated in step (3) |
||||
|
*/ |
||||
|
sha256_init(&ctx->sha); |
||||
|
sha256_update(&ctx->sha, k_ipad, HMAC_SHA256_BLOCKSIZE); |
||||
|
|
||||
|
/*
|
||||
|
* (5) XOR (bitwise exclusive-OR) the B byte string computed in |
||||
|
* step (1) with opad |
||||
|
*/ |
||||
|
xor_block(ctx->k_opad, IPAD^OPAD); |
||||
|
} |
||||
|
|
||||
|
void hmac_sha256_update(struct hmac_sha256_ctx *ctx, const void *p, size_t size) |
||||
|
{ |
||||
|
/* This is the appending-text part of this:
|
||||
|
* |
||||
|
* (3) append the stream of data 'text' to the B byte string resulting |
||||
|
* from step (2) |
||||
|
* (4) apply H to the stream generated in step (3) |
||||
|
*/ |
||||
|
sha256_update(&ctx->sha, p, size); |
||||
|
} |
||||
|
|
||||
|
void hmac_sha256_done(struct hmac_sha256_ctx *ctx, |
||||
|
struct hmac_sha256 *hmac) |
||||
|
{ |
||||
|
/* (4) apply H to the stream generated in step (3) */ |
||||
|
sha256_done(&ctx->sha, &hmac->sha); |
||||
|
|
||||
|
/*
|
||||
|
* (6) append the H result from step (4) to the B byte string |
||||
|
* resulting from step (5) |
||||
|
* (7) apply H to the stream generated in step (6) and output |
||||
|
* the result |
||||
|
*/ |
||||
|
sha256_init(&ctx->sha); |
||||
|
sha256_update(&ctx->sha, ctx->k_opad, sizeof(ctx->k_opad)); |
||||
|
sha256_update(&ctx->sha, &hmac->sha, sizeof(hmac->sha)); |
||||
|
sha256_done(&ctx->sha, &hmac->sha); |
||||
|
} |
||||
|
|
||||
|
#if 1 |
||||
|
void hmac_sha256(struct hmac_sha256 *hmac, |
||||
|
const void *k, size_t ksize, |
||||
|
const void *d, size_t dsize) |
||||
|
{ |
||||
|
struct hmac_sha256_ctx ctx; |
||||
|
|
||||
|
hmac_sha256_init(&ctx, k, ksize); |
||||
|
hmac_sha256_update(&ctx, d, dsize); |
||||
|
hmac_sha256_done(&ctx, hmac); |
||||
|
} |
||||
|
#else |
||||
|
/* Direct mapping from MD5 example in RFC2104 */ |
||||
|
void hmac_sha256(struct hmac_sha256 *hmac, |
||||
|
const void *key, size_t key_len, |
||||
|
const void *text, size_t text_len) |
||||
|
{ |
||||
|
struct sha256_ctx context; |
||||
|
unsigned char k_ipad[65]; /* inner padding -
|
||||
|
* key XORd with ipad |
||||
|
*/ |
||||
|
unsigned char k_opad[65]; /* outer padding -
|
||||
|
* key XORd with opad |
||||
|
*//* start out by storing key in pads */ |
||||
|
unsigned char tk[32]; |
||||
|
int i; |
||||
|
|
||||
|
/* if key is longer than 64 bytes reset it to key=MD5(key) */ |
||||
|
if (key_len > 64) { |
||||
|
|
||||
|
struct sha256_ctx tctx; |
||||
|
|
||||
|
sha256_init(&tctx); |
||||
|
sha256_update(&tctx, key, key_len); |
||||
|
sha256_done(&tctx, tk); |
||||
|
|
||||
|
key = tk; |
||||
|
key_len = 32; |
||||
|
} |
||||
|
bzero( k_ipad, sizeof k_ipad); |
||||
|
bzero( k_opad, sizeof k_opad); |
||||
|
bcopy( key, k_ipad, key_len); |
||||
|
bcopy( key, k_opad, key_len); |
||||
|
|
||||
|
/* XOR key with ipad and opad values */ |
||||
|
for (i=0; i<64; i++) { |
||||
|
k_ipad[i] ^= 0x36; |
||||
|
k_opad[i] ^= 0x5c; |
||||
|
} |
||||
|
/*
|
||||
|
* perform inner MD5 |
||||
|
*/ |
||||
|
sha256_init(&context); /* init context for 1st
|
||||
|
* pass */ |
||||
|
sha256_update(&context, k_ipad, 64); /* start with inner pad */ |
||||
|
sha256_update(&context, text, text_len); /* then text of datagram */ |
||||
|
sha256_done(&context, &hmac->sha); /* finish up 1st pass */ |
||||
|
/*
|
||||
|
* perform outer MD5 |
||||
|
*/ |
||||
|
sha256_init(&context); /* init context for 2nd
|
||||
|
* pass */ |
||||
|
sha256_update(&context, k_opad, 64); /* start with outer pad */ |
||||
|
sha256_update(&context, &hmac->sha, 32); /* then results of 1st
|
||||
|
* hash */ |
||||
|
sha256_done(&context, &hmac->sha); /* finish up 2nd pass */ |
||||
|
} |
||||
|
#endif |
||||
@ -0,0 +1,86 @@ |
|||||
|
#ifndef CCAN_CRYPTO_HMAC_SHA256_H |
||||
|
#define CCAN_CRYPTO_HMAC_SHA256_H |
||||
|
/* BSD-MIT - see LICENSE file for details */ |
||||
|
#include "config.h" |
||||
|
#include <stdint.h> |
||||
|
#include <stdlib.h> |
||||
|
#include <ccan/crypto/sha256/sha256.h> |
||||
|
|
||||
|
/* Number of bytes per block. */ |
||||
|
#define HMAC_SHA256_BLOCKSIZE 64 |
||||
|
|
||||
|
/**
|
||||
|
* struct hmac_sha256 - structure representing a completed HMAC. |
||||
|
*/ |
||||
|
struct hmac_sha256 { |
||||
|
struct sha256 sha; |
||||
|
}; |
||||
|
|
||||
|
/**
|
||||
|
* hmac_sha256 - return hmac of an object with a key. |
||||
|
* @hmac: the hmac to fill in |
||||
|
* @k: pointer to the key, |
||||
|
* @ksize: the number of bytes pointed to by @k |
||||
|
* @d: pointer to memory, |
||||
|
* @dsize: the number of bytes pointed to by @d |
||||
|
*/ |
||||
|
void hmac_sha256(struct hmac_sha256 *hmac, |
||||
|
const void *k, size_t ksize, |
||||
|
const void *d, size_t dsize); |
||||
|
|
||||
|
/**
|
||||
|
* struct hmac_sha256_ctx - structure to store running context for hmac_sha256 |
||||
|
*/ |
||||
|
struct hmac_sha256_ctx { |
||||
|
struct sha256_ctx sha; |
||||
|
uint64_t k_opad[HMAC_SHA256_BLOCKSIZE / sizeof(uint64_t)]; |
||||
|
}; |
||||
|
|
||||
|
/**
|
||||
|
* hmac_sha256_init - initialize an HMAC_SHA256 context. |
||||
|
* @ctx: the hmac_sha256_ctx to initialize |
||||
|
* @k: pointer to the key, |
||||
|
* @ksize: the number of bytes pointed to by @k |
||||
|
* |
||||
|
* This must be called before hmac_sha256_update or hmac_sha256_done. |
||||
|
* |
||||
|
* If it was already initialized, this forgets anything which was |
||||
|
* hashed before. |
||||
|
* |
||||
|
* Example: |
||||
|
* static void hmac_all(const char *key, |
||||
|
* const char **arr, struct hmac_sha256 *hash) |
||||
|
* { |
||||
|
* size_t i; |
||||
|
* struct hmac_sha256_ctx ctx; |
||||
|
* |
||||
|
* hmac_sha256_init(&ctx, key, strlen(key)); |
||||
|
* for (i = 0; arr[i]; i++) |
||||
|
* hmac_sha256_update(&ctx, arr[i], strlen(arr[i])); |
||||
|
* hmac_sha256_done(&ctx, hash); |
||||
|
* } |
||||
|
*/ |
||||
|
void hmac_sha256_init(struct hmac_sha256_ctx *ctx, |
||||
|
const void *k, size_t ksize); |
||||
|
|
||||
|
/**
|
||||
|
* hmac_sha256_update - include some memory in the hash. |
||||
|
* @ctx: the hmac_sha256_ctx to use |
||||
|
* @p: pointer to memory, |
||||
|
* @size: the number of bytes pointed to by @p |
||||
|
* |
||||
|
* You can call this multiple times to hash more data, before calling |
||||
|
* hmac_sha256_done(). |
||||
|
*/ |
||||
|
void hmac_sha256_update(struct hmac_sha256_ctx *ctx, const void *p, size_t size); |
||||
|
|
||||
|
/**
|
||||
|
* hmac_sha256_done - finish HMAC_SHA256 and return the hash |
||||
|
* @ctx: the hmac_sha256_ctx to complete |
||||
|
* @res: the hash to return. |
||||
|
* |
||||
|
* Note that @ctx is *destroyed* by this, and must be reinitialized. |
||||
|
* To avoid that, pass a copy instead. |
||||
|
*/ |
||||
|
void hmac_sha256_done(struct hmac_sha256_ctx *hmac_sha256, struct hmac_sha256 *res); |
||||
|
#endif /* CCAN_CRYPTO_HMAC_SHA256_H */ |
||||
@ -0,0 +1,159 @@ |
|||||
|
/* From RFC4231 "Identifiers and Test Vectors for HMAC-SHA-224, HMAC-SHA-256,
|
||||
|
* HMAC-SHA-384, and HMAC-SHA-512" |
||||
|
* |
||||
|
* https://tools.ietf.org/html/rfc4231
|
||||
|
*/ |
||||
|
#include <ccan/crypto/hmac_sha256/hmac_sha256.h> |
||||
|
#include <ccan/tap/tap.h> |
||||
|
#include <ccan/str/hex/hex.h> |
||||
|
#include <string.h> |
||||
|
#include <assert.h> |
||||
|
|
||||
|
struct test { |
||||
|
const char *key, *data, *hmac; |
||||
|
}; |
||||
|
|
||||
|
static struct test tests[] = { { |
||||
|
/* Test Case 1 */ |
||||
|
"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", /* (20 bytes) */ |
||||
|
"4869205468657265", /* ("Hi There") */ |
||||
|
"b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7" |
||||
|
}, |
||||
|
/* Test Case 2:
|
||||
|
Test with a key shorter than the length of the HMAC output. */ |
||||
|
{ |
||||
|
"4a656665", /* ("Jefe") */ |
||||
|
/* ("what do ya want for nothing?") */ |
||||
|
"7768617420646f2079612077616e7420666f72206e6f7468696e673f", |
||||
|
"5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843" |
||||
|
}, |
||||
|
{ |
||||
|
/* Test Case 3
|
||||
|
|
||||
|
Test with a combined length of key and data that is larger than 64 |
||||
|
bytes (= block-size of SHA-224 and SHA-256). |
||||
|
*/ |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", /* (20 bytes) */ |
||||
|
"dddddddddddddddddddddddddddddddd" |
||||
|
"dddddddddddddddddddddddddddddddd" |
||||
|
"dddddddddddddddddddddddddddddddd" |
||||
|
"dddd", /* (50 bytes) */ |
||||
|
"773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe" |
||||
|
}, |
||||
|
{ |
||||
|
/* Test Case 4
|
||||
|
|
||||
|
Test with a combined length of key and data that is larger than 64 |
||||
|
bytes (= block-size of SHA-224 and SHA-256). |
||||
|
*/ |
||||
|
"0102030405060708090a0b0c0d0e0f10111213141516171819", /* (25 bytes) */ |
||||
|
"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd" |
||||
|
"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd" |
||||
|
"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd" |
||||
|
"cdcd", /* (50 bytes) */ |
||||
|
"82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b" |
||||
|
}, |
||||
|
#if 0 |
||||
|
{ |
||||
|
/* Test Case 5
|
||||
|
|
||||
|
Test with a truncation of output to 128 bits. |
||||
|
*/ |
||||
|
"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c", /* (20 bytes) */ |
||||
|
"546573742057697468205472756e636174696f6e", /* ("Test With Truncation") */ |
||||
|
"a3b6167473100ee06e0c796c2955552b" |
||||
|
}, |
||||
|
#endif |
||||
|
{ |
||||
|
/* Test Case 6
|
||||
|
|
||||
|
Test with a key larger than 128 bytes (= block-size of SHA-384 and |
||||
|
SHA-512). |
||||
|
*/ |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaa", /* (131 bytes) */ |
||||
|
"54657374205573696e67204c61726765" /* ("Test Using Large") */ |
||||
|
"72205468616e20426c6f636b2d53697a" /* ("r Than Block-Siz") */ |
||||
|
"65204b6579202d2048617368204b6579" /* ("e Key - Hash Key") */ |
||||
|
"204669727374", /* (" First") */ |
||||
|
"60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54" |
||||
|
}, |
||||
|
{ |
||||
|
/* Test Case 7
|
||||
|
|
||||
|
Test with a key and data that is larger than 128 bytes (= block-size |
||||
|
of SHA-384 and SHA-512). */ |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
||||
|
"aaaaaa", /* (131 bytes) */ |
||||
|
"54686973206973206120746573742075" /* ("This is a test u") */ |
||||
|
"73696e672061206c6172676572207468" /* ("sing a larger th") */ |
||||
|
"616e20626c6f636b2d73697a65206b65" /* ("an block-size ke") */ |
||||
|
"7920616e642061206c61726765722074" /* ("y and a larger t") */ |
||||
|
"68616e20626c6f636b2d73697a652064" /* ("han block-size d") */ |
||||
|
"6174612e20546865206b6579206e6565" /* ("ata. The key nee") */ |
||||
|
"647320746f2062652068617368656420" /* ("ds to be hashed ") */ |
||||
|
"6265666f7265206265696e6720757365" /* ("before being use") */ |
||||
|
"642062792074686520484d414320616c" /* ("d by the HMAC al") */ |
||||
|
"676f726974686d2e", /* ("gorithm.") */ |
||||
|
"9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2" |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
static void *fromhex(const char *str, size_t *len) |
||||
|
{ |
||||
|
void *p; |
||||
|
|
||||
|
*len = hex_data_size(strlen(str)); |
||||
|
p = malloc(*len); |
||||
|
if (!hex_decode(str, strlen(str), p, *len)) |
||||
|
abort(); |
||||
|
return p; |
||||
|
} |
||||
|
|
||||
|
int main(void) |
||||
|
{ |
||||
|
size_t i; |
||||
|
struct hmac_sha256 hmac; |
||||
|
|
||||
|
plan_tests(sizeof(tests) / sizeof(tests[0]) * 2); |
||||
|
|
||||
|
for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) { |
||||
|
size_t ksize, dsize, hmacsize; |
||||
|
void *k, *d, *expect; |
||||
|
struct hmac_sha256_ctx ctx; |
||||
|
|
||||
|
k = fromhex(tests[i].key, &ksize); |
||||
|
d = fromhex(tests[i].data, &dsize); |
||||
|
expect = fromhex(tests[i].hmac, &hmacsize); |
||||
|
assert(hmacsize == sizeof(hmac)); |
||||
|
hmac_sha256(&hmac, k, ksize, d, dsize); |
||||
|
ok1(memcmp(&hmac, expect, hmacsize) == 0); |
||||
|
|
||||
|
/* Now test partial API. */ |
||||
|
hmac_sha256_init(&ctx, k, ksize); |
||||
|
hmac_sha256_update(&ctx, d, dsize / 2); |
||||
|
hmac_sha256_update(&ctx, (char *)d + dsize/2, dsize - dsize/2); |
||||
|
hmac_sha256_done(&ctx, &hmac); |
||||
|
ok1(memcmp(&hmac, expect, hmacsize) == 0); |
||||
|
|
||||
|
free(k); |
||||
|
free(d); |
||||
|
free(expect); |
||||
|
} |
||||
|
|
||||
|
return exit_status(); |
||||
|
} |
||||
@ -0,0 +1,39 @@ |
|||||
|
#! /usr/bin/make
|
||||
|
|
||||
|
CCANDIR=../../../.. |
||||
|
CFLAGS=-Wall -Werror -O3 -I$(CCANDIR) -DSHACHAIN_BITS=48 |
||||
|
#CFLAGS=-Wall -Werror -g3 -I$(CCANDIR) -DSHACHAIN_BITS=48
|
||||
|
|
||||
|
# 48 bit index for shachain. This is what lightning uses.
|
||||
|
CCAN_OBJS:=ccan-str.o ccan-err.o ccan-hex.o ccan-shachain.o ccan-sha256.o ccan-rbuf.o |
||||
|
|
||||
|
all: shachain48 |
||||
|
|
||||
|
shachain48: shachain48.o $(CCAN_OBJS) |
||||
|
|
||||
|
shachain48.o: $(CCANDIR)/ccan/crypto/shachain/shachain.h \ |
||||
|
$(CCANDIR)/ccan/str/hex/hex.h \
|
||||
|
$(CCANDIR)/ccan/str/str.h \
|
||||
|
$(CCANDIR)/ccan/err/err.h \
|
||||
|
$(CCANDIR)/ccan/rbuf/rbuf.h |
||||
|
|
||||
|
shachain48.o $(CCAN_OBJS): $(CCANDIR)/config.h |
||||
|
|
||||
|
$(CCANDIR)/config.h: |
||||
|
$(MAKE) -C $(CCANDIR) config.h |
||||
|
|
||||
|
clean: |
||||
|
rm -f shachain *.o |
||||
|
|
||||
|
ccan-err.o: $(CCANDIR)/ccan/err/err.c |
||||
|
$(CC) $(CFLAGS) -c -o $@ $< |
||||
|
ccan-hex.o: $(CCANDIR)/ccan/str/hex/hex.c |
||||
|
$(CC) $(CFLAGS) -c -o $@ $< |
||||
|
ccan-str.o: $(CCANDIR)/ccan/str/str.c |
||||
|
$(CC) $(CFLAGS) -c -o $@ $< |
||||
|
ccan-shachain.o: $(CCANDIR)/ccan/crypto/shachain/shachain.c |
||||
|
$(CC) $(CFLAGS) -c -o $@ $< |
||||
|
ccan-sha256.o: $(CCANDIR)/ccan/crypto/sha256/sha256.c |
||||
|
$(CC) $(CFLAGS) -c -o $@ $< |
||||
|
ccan-rbuf.o: $(CCANDIR)/ccan/rbuf/rbuf.c |
||||
|
$(CC) $(CFLAGS) -c -o $@ $< |
||||
@ -0,0 +1,58 @@ |
|||||
|
#include <ccan/crypto/shachain/shachain.h> |
||||
|
#include <ccan/str/hex/hex.h> |
||||
|
#include <ccan/str/str.h> |
||||
|
#include <ccan/err/err.h> |
||||
|
#include <ccan/rbuf/rbuf.h> |
||||
|
#include <stdio.h> |
||||
|
#include <stdlib.h> |
||||
|
#include <unistd.h> |
||||
|
|
||||
|
int main(int argc, char *argv[]) |
||||
|
{ |
||||
|
if (argc == 2 && streq(argv[1], "--store")) { |
||||
|
struct shachain s; |
||||
|
struct rbuf rbuf; |
||||
|
size_t size = rbuf_good_size(STDIN_FILENO); |
||||
|
char *p; |
||||
|
|
||||
|
shachain_init(&s); |
||||
|
rbuf_init(&rbuf, STDIN_FILENO, malloc(size), size); |
||||
|
|
||||
|
while ((p = rbuf_read_str(&rbuf, '\n', realloc)) != NULL) { |
||||
|
struct sha256 hash; |
||||
|
unsigned long long idx; |
||||
|
|
||||
|
if (strstarts(p, "0x")) |
||||
|
p += 2; |
||||
|
if (!hex_decode(p, 64, &hash, sizeof(hash))) |
||||
|
errx(2, "%.*s is not 64 chars of hex", 64, p); |
||||
|
p += 64; |
||||
|
p += strspn(p, " \t"); |
||||
|
idx = strtoull(p, NULL, 0); |
||||
|
if (shachain_add_hash(&s, idx, &hash)) |
||||
|
printf("OK\n"); |
||||
|
else |
||||
|
printf("ERROR\n"); |
||||
|
} |
||||
|
} else if (argc == 3) { |
||||
|
struct sha256 seed, hash; |
||||
|
const char *p; |
||||
|
unsigned long long idx; |
||||
|
char hex[65]; |
||||
|
|
||||
|
if (strstarts(argv[1], "0x")) |
||||
|
p = argv[1] + 2; |
||||
|
else |
||||
|
p = argv[1]; |
||||
|
idx = strtoull(argv[2], NULL, 0); |
||||
|
|
||||
|
if (!hex_decode(p, 64, &seed, sizeof(seed))) |
||||
|
errx(2, "%s is not 64 chars of hex", p); |
||||
|
|
||||
|
shachain_from_seed(&seed, idx, &hash); |
||||
|
hex_encode(&hash, sizeof(hash), hex, sizeof(hex)); |
||||
|
printf("0x%s\n", hex); |
||||
|
} else |
||||
|
errx(1, "Usage: shachain --store OR shachain <seed> <index>"); |
||||
|
return 0; |
||||
|
} |
||||
@ -0,0 +1 @@ |
|||||
|
../../licenses/CC0 |
||||
@ -0,0 +1,65 @@ |
|||||
|
#include "config.h" |
||||
|
#include <stdio.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
/** |
||||
|
* fdpass - routines to pass a file descriptor over a socket. |
||||
|
* |
||||
|
* This code handles all the hairy details of fd passing. |
||||
|
* |
||||
|
* License: CC0 (Public domain) |
||||
|
* Maintainer: Rusty Russell <rusty@rustcorp.com.au> |
||||
|
* |
||||
|
* Example: |
||||
|
* // Outputs hello! |
||||
|
* #include <ccan/fdpass/fdpass.h> |
||||
|
* #include <sys/socket.h> |
||||
|
* #include <sys/un.h> |
||||
|
* #include <stdio.h> |
||||
|
* #include <stdlib.h> |
||||
|
* #include <unistd.h> |
||||
|
* |
||||
|
* static void child(int sockfd) |
||||
|
* { |
||||
|
* char buffer[6]; |
||||
|
* int newfd = fdpass_recv(sockfd); |
||||
|
* read(newfd, buffer, sizeof(buffer)); |
||||
|
* printf("%.*s\n", (int)sizeof(buffer), buffer); |
||||
|
* exit(0); |
||||
|
* } |
||||
|
* |
||||
|
* static void parent(int sockfd) |
||||
|
* { |
||||
|
* int pfds[2]; |
||||
|
* |
||||
|
* pipe(pfds); |
||||
|
* fdpass_send(sockfd, pfds[0]); |
||||
|
* close(pfds[0]); |
||||
|
* write(pfds[1], "hello!", 6); |
||||
|
* exit(0); |
||||
|
* } |
||||
|
* |
||||
|
* int main(void) |
||||
|
* { |
||||
|
* int sv[2]; |
||||
|
* |
||||
|
* socketpair(AF_UNIX, SOCK_STREAM, 0, sv); |
||||
|
* if (fork() == 0) |
||||
|
* child(sv[0]); |
||||
|
* else |
||||
|
* parent(sv[1]); |
||||
|
* } |
||||
|
*/ |
||||
|
int main(int argc, char *argv[]) |
||||
|
{ |
||||
|
/* Expect exactly one argument */ |
||||
|
if (argc != 2) |
||||
|
return 1; |
||||
|
|
||||
|
if (strcmp(argv[1], "depends") == 0) |
||||
|
return 0; |
||||
|
|
||||
|
return 1; |
||||
|
} |
||||
|
|
||||
|
|
||||
@ -0,0 +1,83 @@ |
|||||
|
/* CC0 license (public domain) - see LICENSE file for details */ |
||||
|
#include <ccan/fdpass/fdpass.h> |
||||
|
#include <sys/socket.h> |
||||
|
#include <errno.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
bool fdpass_send(int sockout, int fd) |
||||
|
{ |
||||
|
/* From the cmsg(3) manpage: */ |
||||
|
struct msghdr msg = { 0 }; |
||||
|
struct cmsghdr *cmsg; |
||||
|
struct iovec iov; |
||||
|
char c = 0; |
||||
|
union { /* Ancillary data buffer, wrapped in a union
|
||||
|
in order to ensure it is suitably aligned */ |
||||
|
char buf[CMSG_SPACE(sizeof(fd))]; |
||||
|
struct cmsghdr align; |
||||
|
} u; |
||||
|
|
||||
|
msg.msg_control = u.buf; |
||||
|
msg.msg_controllen = sizeof(u.buf); |
||||
|
memset(&u, 0, sizeof(u)); |
||||
|
cmsg = CMSG_FIRSTHDR(&msg); |
||||
|
cmsg->cmsg_level = SOL_SOCKET; |
||||
|
cmsg->cmsg_type = SCM_RIGHTS; |
||||
|
cmsg->cmsg_len = CMSG_LEN(sizeof(fd)); |
||||
|
memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd)); |
||||
|
|
||||
|
msg.msg_name = NULL; |
||||
|
msg.msg_namelen = 0; |
||||
|
msg.msg_iov = &iov; |
||||
|
msg.msg_iovlen = 1; |
||||
|
msg.msg_flags = 0; |
||||
|
|
||||
|
/* Keith Packard reports that 0-length sends don't work, so we
|
||||
|
* always send 1 byte. */ |
||||
|
iov.iov_base = &c; |
||||
|
iov.iov_len = 1; |
||||
|
|
||||
|
return sendmsg(sockout, &msg, 0) == 1; |
||||
|
} |
||||
|
|
||||
|
int fdpass_recv(int sockin) |
||||
|
{ |
||||
|
/* From the cmsg(3) manpage: */ |
||||
|
struct msghdr msg = { 0 }; |
||||
|
struct cmsghdr *cmsg; |
||||
|
struct iovec iov; |
||||
|
int fd; |
||||
|
char c; |
||||
|
union { /* Ancillary data buffer, wrapped in a union
|
||||
|
in order to ensure it is suitably aligned */ |
||||
|
char buf[CMSG_SPACE(sizeof(fd))]; |
||||
|
struct cmsghdr align; |
||||
|
} u; |
||||
|
|
||||
|
msg.msg_control = u.buf; |
||||
|
msg.msg_controllen = sizeof(u.buf); |
||||
|
|
||||
|
msg.msg_name = NULL; |
||||
|
msg.msg_namelen = 0; |
||||
|
msg.msg_iov = &iov; |
||||
|
msg.msg_iovlen = 1; |
||||
|
msg.msg_flags = 0; |
||||
|
|
||||
|
iov.iov_base = &c; |
||||
|
iov.iov_len = 1; |
||||
|
|
||||
|
if (recvmsg(sockin, &msg, 0) < 0) |
||||
|
return -1; |
||||
|
|
||||
|
cmsg = CMSG_FIRSTHDR(&msg); |
||||
|
if (!cmsg |
||||
|
|| cmsg->cmsg_len != CMSG_LEN(sizeof(fd)) |
||||
|
|| cmsg->cmsg_level != SOL_SOCKET |
||||
|
|| cmsg->cmsg_type != SCM_RIGHTS) { |
||||
|
errno = -EINVAL; |
||||
|
return -1; |
||||
|
} |
||||
|
|
||||
|
memcpy(&fd, CMSG_DATA(cmsg), sizeof(fd)); |
||||
|
return fd; |
||||
|
} |
||||
@ -0,0 +1,23 @@ |
|||||
|
/* CC0 license (public domain) - see LICENSE file for details */ |
||||
|
#ifndef CCAN_FDPASS_H |
||||
|
#define CCAN_FDPASS_H |
||||
|
|
||||
|
#include <stdbool.h> |
||||
|
|
||||
|
/**
|
||||
|
* fdpass_send - send a file descriptor across a socket |
||||
|
* @sockout: socket to write to |
||||
|
* @fd: file descriptor to pass |
||||
|
* |
||||
|
* On failure, sets errno and returns false. |
||||
|
*/ |
||||
|
bool fdpass_send(int sockout, int fd); |
||||
|
|
||||
|
/**
|
||||
|
* fdpass_recv - receive a file descriptor from a socket |
||||
|
* @sockin: socket to read from |
||||
|
* |
||||
|
* On failure, returns -1 and sets errno. Otherwise returns fd. |
||||
|
*/ |
||||
|
int fdpass_recv(int sockin); |
||||
|
#endif /* CCAN_FDPASS_H */ |
||||
@ -0,0 +1,88 @@ |
|||||
|
#include <ccan/fdpass/fdpass.h> |
||||
|
/* Include the C files directly. */ |
||||
|
#include <ccan/fdpass/fdpass.c> |
||||
|
#include <ccan/tap/tap.h> |
||||
|
|
||||
|
#include <sys/types.h> |
||||
|
#include <sys/wait.h> |
||||
|
#include <sys/un.h> |
||||
|
#include <stdio.h> |
||||
|
#include <stdlib.h> |
||||
|
#include <unistd.h> |
||||
|
#include <assert.h> |
||||
|
|
||||
|
static void child(int sockfd) |
||||
|
{ |
||||
|
char c; |
||||
|
int newfd = fdpass_recv(sockfd); |
||||
|
assert(newfd >= 0); |
||||
|
assert(read(newfd, &c, 1) == 1); |
||||
|
assert(c == 0x77); |
||||
|
exit(0); |
||||
|
} |
||||
|
|
||||
|
static void child_nofd(int sockfd) |
||||
|
{ |
||||
|
assert(fdpass_recv(sockfd) == -1); |
||||
|
exit(0); |
||||
|
} |
||||
|
|
||||
|
static void parent(int sockfd) |
||||
|
{ |
||||
|
int pfds[2]; |
||||
|
|
||||
|
ok1(pipe(pfds) == 0); |
||||
|
ok1(fdpass_send(sockfd, pfds[0])); |
||||
|
ok1(close(pfds[0]) == 0); |
||||
|
ok1(write(pfds[1], "\x77", 1) == 1); |
||||
|
ok1(close(pfds[1]) == 0); |
||||
|
} |
||||
|
|
||||
|
int main(void) |
||||
|
{ |
||||
|
int sv[2]; |
||||
|
int pid, wstatus; |
||||
|
|
||||
|
plan_tests(17); |
||||
|
ok1(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0); |
||||
|
|
||||
|
pid = fork(); |
||||
|
if (pid == 0) { |
||||
|
close(sv[1]); |
||||
|
child(sv[0]); |
||||
|
} |
||||
|
|
||||
|
parent(sv[1]); |
||||
|
ok1(waitpid(pid, &wstatus, 0) == pid); |
||||
|
ok1(WIFEXITED(wstatus)); |
||||
|
ok1(WEXITSTATUS(wstatus) == 0); |
||||
|
|
||||
|
pid = fork(); |
||||
|
if (pid == 0) { |
||||
|
close(sv[1]); |
||||
|
child_nofd(sv[0]); |
||||
|
} |
||||
|
/* Don't write an fd. */ |
||||
|
ok1(write(sv[1], "1", 1) == 1); |
||||
|
ok1(waitpid(pid, &wstatus, 0) == pid); |
||||
|
ok1(WIFEXITED(wstatus)); |
||||
|
ok1(WEXITSTATUS(wstatus) == 0); |
||||
|
|
||||
|
pid = fork(); |
||||
|
if (pid == 0) { |
||||
|
close(sv[1]); |
||||
|
child_nofd(sv[0]); |
||||
|
} |
||||
|
/* Don't write anything. */ |
||||
|
close(sv[1]); |
||||
|
ok1(waitpid(pid, &wstatus, 0) == pid); |
||||
|
ok1(WIFEXITED(wstatus)); |
||||
|
ok1(WEXITSTATUS(wstatus) == 0); |
||||
|
|
||||
|
close(sv[0]); |
||||
|
/* Test fdpass_recv from invalid fd. */ |
||||
|
ok1(fdpass_recv(sv[0]) == -1 && errno == EBADF); |
||||
|
|
||||
|
/* This exits depending on whether all tests passed */ |
||||
|
return exit_status(); |
||||
|
} |
||||
@ -0,0 +1 @@ |
|||||
|
../../../licenses/LGPL-2.1 |
||||
@ -0,0 +1,95 @@ |
|||||
|
#include "config.h" |
||||
|
#include <stdio.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
/** |
||||
|
* io/fdpass - IO helper for passing file descriptors across local sockets |
||||
|
* |
||||
|
* This code adds the ability to pass file descriptors to ccan/io. |
||||
|
* |
||||
|
* License: LGPL (v2.1 or any later version) |
||||
|
* Author: Rusty Russell <rusty@rustcorp.com.au> |
||||
|
* |
||||
|
* Example: |
||||
|
* // Given "hello" outputs hello |
||||
|
* #include <ccan/io/fdpass/fdpass.h> |
||||
|
* #include <sys/types.h> |
||||
|
* #include <sys/socket.h> |
||||
|
* #include <sys/un.h> |
||||
|
* #include <stdio.h> |
||||
|
* #include <stdlib.h> |
||||
|
* #include <unistd.h> |
||||
|
* |
||||
|
* // Child reads stdin into the buffer, prints it out. |
||||
|
* struct buf { |
||||
|
* size_t used; |
||||
|
* char c[100]; |
||||
|
* }; |
||||
|
* static struct io_plan *read_more(struct io_conn *conn, struct buf *buf) |
||||
|
* { |
||||
|
* printf("%.*s", (int)buf->used, buf->c); |
||||
|
* return io_read_partial(conn, buf->c, sizeof(buf->c), &buf->used, |
||||
|
* read_more, buf); |
||||
|
* } |
||||
|
* |
||||
|
* // Child has received fd, start reading loop. |
||||
|
* static struct io_plan *got_infd(struct io_conn *conn, int *infd) |
||||
|
* { |
||||
|
* struct buf *buf = calloc(1, sizeof(*buf)); |
||||
|
* |
||||
|
* io_new_conn(NULL, *infd, read_more, buf); |
||||
|
* return io_close(conn); |
||||
|
* } |
||||
|
* // Child is receiving the fd to read into. |
||||
|
* static struct io_plan *recv_infd(struct io_conn *conn, int *infd) |
||||
|
* { |
||||
|
* return io_recv_fd(conn, infd, got_infd, infd); |
||||
|
* } |
||||
|
* |
||||
|
* // Gets passed fd (stdin), which it reads from. |
||||
|
* static void child(int sockfd) |
||||
|
* { |
||||
|
* int infd; |
||||
|
* |
||||
|
* io_new_conn(NULL, sockfd, recv_infd, &infd); |
||||
|
* io_loop(NULL, NULL); |
||||
|
* exit(0); |
||||
|
* } |
||||
|
* |
||||
|
* static struct io_plan *send_stdin(struct io_conn *conn, void *unused) |
||||
|
* { |
||||
|
* return io_send_fd(conn, STDIN_FILENO, io_close_cb, NULL); |
||||
|
* } |
||||
|
* |
||||
|
* static void parent(int sockfd) |
||||
|
* { |
||||
|
* io_new_conn(NULL, sockfd, send_stdin, NULL); |
||||
|
* io_loop(NULL, NULL); |
||||
|
* exit(0); |
||||
|
* } |
||||
|
* |
||||
|
* int main(void) |
||||
|
* { |
||||
|
* int sv[2]; |
||||
|
* |
||||
|
* socketpair(AF_UNIX, SOCK_STREAM, 0, sv); |
||||
|
* if (fork() == 0) |
||||
|
* child(sv[0]); |
||||
|
* else |
||||
|
* parent(sv[1]); |
||||
|
* } |
||||
|
*/ |
||||
|
int main(int argc, char *argv[]) |
||||
|
{ |
||||
|
/* Expect exactly one argument */ |
||||
|
if (argc != 2) |
||||
|
return 1; |
||||
|
|
||||
|
if (strcmp(argv[1], "depends") == 0) { |
||||
|
printf("ccan/fdpass\n"); |
||||
|
printf("ccan/io\n"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
return 1; |
||||
|
} |
||||
@ -0,0 +1,54 @@ |
|||||
|
/* GNU LGPL version 2 (or later) - see LICENSE file for details */ |
||||
|
#include <ccan/io/fdpass/fdpass.h> |
||||
|
#include <ccan/fdpass/fdpass.h> |
||||
|
#include <ccan/io/io_plan.h> |
||||
|
#include <errno.h> |
||||
|
|
||||
|
static int do_fd_send(int fd, struct io_plan_arg *arg) |
||||
|
{ |
||||
|
if (!fdpass_send(fd, arg->u1.s)) { |
||||
|
/* In case ccan/io ever gets smart with non-blocking. */ |
||||
|
if (errno == EAGAIN || errno == EWOULDBLOCK) |
||||
|
return 0; |
||||
|
return -1; |
||||
|
} |
||||
|
return 1; |
||||
|
} |
||||
|
|
||||
|
struct io_plan *io_send_fd_(struct io_conn *conn, |
||||
|
int fd, |
||||
|
struct io_plan *(*next)(struct io_conn *, void *), |
||||
|
void *next_arg) |
||||
|
{ |
||||
|
struct io_plan_arg *arg = io_plan_arg(conn, IO_OUT); |
||||
|
|
||||
|
arg->u1.s = fd; |
||||
|
|
||||
|
return io_set_plan(conn, IO_OUT, do_fd_send, next, next_arg); |
||||
|
} |
||||
|
|
||||
|
static int do_fd_recv(int fd, struct io_plan_arg *arg) |
||||
|
{ |
||||
|
int fdin = fdpass_recv(fd); |
||||
|
|
||||
|
if (fdin < 0) { |
||||
|
/* In case ccan/io ever gets smart with non-blocking. */ |
||||
|
if (errno == EAGAIN || errno == EWOULDBLOCK) |
||||
|
return 0; |
||||
|
return -1; |
||||
|
} |
||||
|
*(int *)arg->u1.vp = fdin; |
||||
|
return 1; |
||||
|
} |
||||
|
|
||||
|
struct io_plan *io_recv_fd_(struct io_conn *conn, |
||||
|
int *fd, |
||||
|
struct io_plan *(*next)(struct io_conn *, void *), |
||||
|
void *next_arg) |
||||
|
{ |
||||
|
struct io_plan_arg *arg = io_plan_arg(conn, IO_IN); |
||||
|
|
||||
|
arg->u1.vp = fd; |
||||
|
|
||||
|
return io_set_plan(conn, IO_IN, do_fd_recv, next, next_arg); |
||||
|
} |
||||
@ -0,0 +1,68 @@ |
|||||
|
/* GNU LGPL version 2 (or later) - see LICENSE file for details */ |
||||
|
#ifndef CCAN_IO_FDPASS_H |
||||
|
#define CCAN_IO_FDPASS_H |
||||
|
#include <ccan/io/io.h> |
||||
|
|
||||
|
/**
|
||||
|
* io_send_fd - output plan to send a file descriptor |
||||
|
* @conn: the connection that plan is for. |
||||
|
* @fd: the file descriptor to pass. |
||||
|
* @next: function to call output is done. |
||||
|
* @arg: @next argument |
||||
|
* |
||||
|
* This updates the output plan, to write out a file descriptor. This |
||||
|
* usually only works over an AF_LOCAL (ie. Unix domain) socket. Once |
||||
|
* that's sent, the @next function will be called: on an error, the |
||||
|
* finish function is called instead. |
||||
|
* |
||||
|
* Note that the I/O may actually be done immediately, and the other end |
||||
|
* of the socket must use io_recv_fd: if it does a normal read, the file |
||||
|
* descriptor will be lost. |
||||
|
* |
||||
|
* Example: |
||||
|
* static struct io_plan *fd_to_conn(struct io_conn *conn, int fd) |
||||
|
* { |
||||
|
* // Write fd, then close.
|
||||
|
* return io_send_fd(conn, fd, io_close_cb, NULL); |
||||
|
* } |
||||
|
*/ |
||||
|
#define io_send_fd(conn, fd, next, arg) \ |
||||
|
io_send_fd_((conn), (fd), \ |
||||
|
typesafe_cb_preargs(struct io_plan *, void *, \ |
||||
|
(next), (arg), struct io_conn *), \ |
||||
|
(arg)) |
||||
|
struct io_plan *io_send_fd_(struct io_conn *conn, |
||||
|
int fd, |
||||
|
struct io_plan *(*next)(struct io_conn *, void *), |
||||
|
void *arg); |
||||
|
|
||||
|
/**
|
||||
|
* io_recv_fd - input plan to receive a file descriptor |
||||
|
* @conn: the connection that plan is for. |
||||
|
* @fd: a pointer to where to place to file descriptor |
||||
|
* @next: function to call once input is done. |
||||
|
* @arg: @next argument |
||||
|
* |
||||
|
* This creates a plan to receive a file descriptor, as sent by |
||||
|
* io_send_fd. Once it's all read, the @next function will be called: |
||||
|
* on an error, the finish function is called instead. |
||||
|
* |
||||
|
* Note that the I/O may actually be done immediately. |
||||
|
* |
||||
|
* Example: |
||||
|
* static struct io_plan *read_from_conn(struct io_conn *conn, int *fdp) |
||||
|
* { |
||||
|
* // Read message, then close.
|
||||
|
* return io_recv_fd(conn, fdp, io_close_cb, NULL); |
||||
|
* } |
||||
|
*/ |
||||
|
#define io_recv_fd(conn, fd, next, arg) \ |
||||
|
io_recv_fd_((conn), (fd), \ |
||||
|
typesafe_cb_preargs(struct io_plan *, void *, \ |
||||
|
(next), (arg), struct io_conn *), \ |
||||
|
(arg)) |
||||
|
struct io_plan *io_recv_fd_(struct io_conn *conn, |
||||
|
int *fd, |
||||
|
struct io_plan *(*next)(struct io_conn *, void *), |
||||
|
void *arg); |
||||
|
#endif /* CCAN_IO_FDPASS_H */ |
||||
@ -0,0 +1,51 @@ |
|||||
|
#include <ccan/io/fdpass/fdpass.h> |
||||
|
/* Include the C files directly. */ |
||||
|
#include <ccan/io/fdpass/fdpass.c> |
||||
|
#include <ccan/tap/tap.h> |
||||
|
#include <sys/types.h> |
||||
|
#include <sys/socket.h> |
||||
|
|
||||
|
static struct io_plan *try_reading(struct io_conn *conn, int *fd) |
||||
|
{ |
||||
|
char buf[6]; |
||||
|
ok1(read(*fd, buf, sizeof(buf)) == sizeof(buf)); |
||||
|
ok1(memcmp(buf, "hello!", sizeof(buf)) == 0); |
||||
|
return io_close(conn); |
||||
|
} |
||||
|
|
||||
|
static struct io_plan *get_fd(struct io_conn *conn, void *unused) |
||||
|
{ |
||||
|
int *fd = tal(conn, int); |
||||
|
return io_recv_fd(conn, fd, try_reading, fd); |
||||
|
} |
||||
|
|
||||
|
static struct io_plan *try_writing(struct io_conn *conn, int *pfd) |
||||
|
{ |
||||
|
close(pfd[0]); |
||||
|
ok1(write(pfd[1], "hello!", 6) == 6); |
||||
|
return io_close(conn); |
||||
|
} |
||||
|
|
||||
|
static struct io_plan *send_fd(struct io_conn *conn, int *pfd) |
||||
|
{ |
||||
|
return io_send_fd(conn, pfd[0], try_writing, pfd); |
||||
|
} |
||||
|
|
||||
|
int main(void) |
||||
|
{ |
||||
|
int sv[2]; |
||||
|
int pfd[2]; |
||||
|
|
||||
|
plan_tests(5); |
||||
|
ok1(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0); |
||||
|
ok1(pipe(pfd) == 0); |
||||
|
|
||||
|
/* Pass read end of pipe to ourselves, test. */ |
||||
|
io_new_conn(NULL, sv[0], get_fd, NULL); |
||||
|
io_new_conn(NULL, sv[1], send_fd, pfd); |
||||
|
|
||||
|
io_loop(NULL, NULL); |
||||
|
|
||||
|
/* This exits depending on whether all tests passed */ |
||||
|
return exit_status(); |
||||
|
} |
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-01-start-finish.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-02-read.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-03-readpartial.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-04-writepartial.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-05-write.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-07-break.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-09-connect.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-12-bidir.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-14-duplex-both-read.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-16-duplex-test.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-17-homemade-io.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-18-errno.c" |
|
||||
@ -1,2 +0,0 @@ |
|||||
#define DEBUG_CONN |
|
||||
#include "run-19-always.c" |
|
||||
@ -0,0 +1 @@ |
|||||
|
../../licenses/BSD-MIT |
||||
@ -0,0 +1,29 @@ |
|||||
|
#include "config.h" |
||||
|
#include <stdio.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
/** |
||||
|
* ptr_valid - test whether a pointer is safe to dereference. |
||||
|
* |
||||
|
* This little helper tells you if an address is mapped; it doesn't tell you |
||||
|
* if it's read-only (or execute only). |
||||
|
* |
||||
|
* License: BSD-MIT |
||||
|
* |
||||
|
* Ccanlint: |
||||
|
* // Our child actually crashes, but that's OK! |
||||
|
* tests_pass_valgrind test/run.c:--child-silent-after-fork=yes |
||||
|
*/ |
||||
|
int main(int argc, char *argv[]) |
||||
|
{ |
||||
|
/* Expect exactly one argument */ |
||||
|
if (argc != 2) |
||||
|
return 1; |
||||
|
|
||||
|
if (strcmp(argv[1], "depends") == 0) { |
||||
|
printf("ccan/noerr\n"); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
return 1; |
||||
|
} |
||||
@ -0,0 +1,344 @@ |
|||||
|
// Licensed under BSD-MIT: See LICENSE.
|
||||
|
#include "ptr_valid.h" |
||||
|
#include <sys/types.h> |
||||
|
#include <sys/wait.h> |
||||
|
#include <sys/stat.h> |
||||
|
#include <fcntl.h> |
||||
|
#include <ccan/noerr/noerr.h> |
||||
|
#include <unistd.h> |
||||
|
#include <errno.h> |
||||
|
#include <assert.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
#if HAVE_PROC_SELF_MAPS |
||||
|
static char *grab(const char *filename) |
||||
|
{ |
||||
|
int ret, fd; |
||||
|
size_t max = 16384, s = 0; |
||||
|
char *buffer; |
||||
|
|
||||
|
fd = open(filename, O_RDONLY); |
||||
|
if (fd < 0) |
||||
|
return NULL; |
||||
|
|
||||
|
buffer = malloc(max+1); |
||||
|
if (!buffer) |
||||
|
goto close; |
||||
|
|
||||
|
while ((ret = read(fd, buffer + s, max - s)) > 0) { |
||||
|
s += ret; |
||||
|
if (s == max) { |
||||
|
buffer = realloc(buffer, max*2+1); |
||||
|
if (!buffer) |
||||
|
goto close; |
||||
|
max *= 2; |
||||
|
} |
||||
|
} |
||||
|
if (ret < 0) |
||||
|
goto free; |
||||
|
|
||||
|
close(fd); |
||||
|
buffer[s] = '\0'; |
||||
|
return buffer; |
||||
|
|
||||
|
free: |
||||
|
free(buffer); |
||||
|
close: |
||||
|
close_noerr(fd); |
||||
|
return NULL; |
||||
|
} |
||||
|
|
||||
|
static char *skip_line(char *p) |
||||
|
{ |
||||
|
char *nl = strchr(p, '\n'); |
||||
|
if (!nl) |
||||
|
return NULL; |
||||
|
return nl + 1; |
||||
|
} |
||||
|
|
||||
|
static struct ptr_valid_map *add_map(struct ptr_valid_map *map, |
||||
|
unsigned int *num, |
||||
|
unsigned int *max, |
||||
|
unsigned long start, unsigned long end, bool is_write) |
||||
|
{ |
||||
|
if (*num == *max) { |
||||
|
*max *= 2; |
||||
|
map = realloc(map, sizeof(*map) * *max); |
||||
|
if (!map) |
||||
|
return NULL; |
||||
|
} |
||||
|
map[*num].start = (void *)start; |
||||
|
map[*num].end = (void *)end; |
||||
|
map[*num].is_write = is_write; |
||||
|
(*num)++; |
||||
|
return map; |
||||
|
} |
||||
|
|
||||
|
static struct ptr_valid_map *get_proc_maps(unsigned int *num) |
||||
|
{ |
||||
|
char *buf, *p; |
||||
|
struct ptr_valid_map *map; |
||||
|
unsigned int max = 16; |
||||
|
|
||||
|
buf = grab("/proc/self/maps"); |
||||
|
if (!buf) { |
||||
|
*num = 0; |
||||
|
return NULL; |
||||
|
} |
||||
|
|
||||
|
map = malloc(sizeof(*map) * max); |
||||
|
if (!map) |
||||
|
goto free_buf; |
||||
|
|
||||
|
*num = 0; |
||||
|
for (p = buf; p && *p; p = skip_line(p)) { |
||||
|
unsigned long start, end; |
||||
|
char *endp; |
||||
|
|
||||
|
/* Expect '<start-in-hex>-<end-in-hex> rw... */ |
||||
|
start = strtoul(p, &endp, 16); |
||||
|
if (*endp != '-') |
||||
|
goto malformed; |
||||
|
end = strtoul(endp+1, &endp, 16); |
||||
|
if (*endp != ' ') |
||||
|
goto malformed; |
||||
|
|
||||
|
endp++; |
||||
|
if (endp[0] != 'r' && endp[0] != '-') |
||||
|
goto malformed; |
||||
|
if (endp[1] != 'w' && endp[1] != '-') |
||||
|
goto malformed; |
||||
|
|
||||
|
/* We only add readable mappings. */ |
||||
|
if (endp[0] == 'r') { |
||||
|
map = add_map(map, num, &max, start, end, |
||||
|
endp[1] == 'w'); |
||||
|
if (!map) |
||||
|
goto free_buf; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
free(buf); |
||||
|
return map; |
||||
|
|
||||
|
|
||||
|
malformed: |
||||
|
free(map); |
||||
|
free_buf: |
||||
|
free(buf); |
||||
|
*num = 0; |
||||
|
return NULL; |
||||
|
} |
||||
|
#else |
||||
|
static struct ptr_valid_map *get_proc_maps(unsigned int *num) |
||||
|
{ |
||||
|
*num = 0; |
||||
|
return NULL; |
||||
|
} |
||||
|
#endif |
||||
|
|
||||
|
static bool check_with_maps(struct ptr_valid_batch *batch, |
||||
|
const char *p, size_t size, bool is_write) |
||||
|
{ |
||||
|
unsigned int i; |
||||
|
|
||||
|
for (i = 0; i < batch->num_maps; i++) { |
||||
|
if (p >= batch->maps[i].start && p < batch->maps[i].end) { |
||||
|
/* Overlap into other maps? Recurse with remainder. */ |
||||
|
if (p + size > batch->maps[i].end) { |
||||
|
size_t len = p + size - batch->maps[i].end; |
||||
|
if (!check_with_maps(batch, batch->maps[i].end, |
||||
|
len, is_write)) |
||||
|
return false; |
||||
|
} |
||||
|
return !is_write || batch->maps[i].is_write; |
||||
|
} |
||||
|
} |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
static void finish_child(struct ptr_valid_batch *batch) |
||||
|
{ |
||||
|
close(batch->to_child); |
||||
|
close(batch->from_child); |
||||
|
waitpid(batch->child_pid, NULL, 0); |
||||
|
batch->child_pid = 0; |
||||
|
} |
||||
|
|
||||
|
static bool child_alive(struct ptr_valid_batch *batch) |
||||
|
{ |
||||
|
return batch->child_pid != 0; |
||||
|
} |
||||
|
|
||||
|
static void run_child(int infd, int outfd) |
||||
|
{ |
||||
|
volatile char *p; |
||||
|
|
||||
|
/* This is how we expect to exit. */ |
||||
|
while (read(infd, &p, sizeof(p)) == sizeof(p)) { |
||||
|
size_t i, size; |
||||
|
bool is_write; |
||||
|
char ret = 0; |
||||
|
|
||||
|
/* This is weird. */ |
||||
|
if (read(infd, &size, sizeof(size)) != sizeof(size)) |
||||
|
exit(1); |
||||
|
if (read(infd, &is_write, sizeof(is_write)) != sizeof(is_write)) |
||||
|
exit(2); |
||||
|
|
||||
|
for (i = 0; i < size; i++) { |
||||
|
ret = p[i]; |
||||
|
if (is_write) |
||||
|
p[i] = ret; |
||||
|
} |
||||
|
|
||||
|
/* If we're still here, the answer is "yes". */ |
||||
|
if (write(outfd, &ret, 1) != 1) |
||||
|
exit(3); |
||||
|
} |
||||
|
exit(0); |
||||
|
} |
||||
|
|
||||
|
static bool create_child(struct ptr_valid_batch *batch) |
||||
|
{ |
||||
|
int outpipe[2], inpipe[2]; |
||||
|
|
||||
|
if (pipe(outpipe) != 0) |
||||
|
return false; |
||||
|
if (pipe(inpipe) != 0) |
||||
|
goto close_outpipe; |
||||
|
|
||||
|
fflush(stdout); |
||||
|
batch->child_pid = fork(); |
||||
|
if (batch->child_pid == 0) { |
||||
|
close(outpipe[1]); |
||||
|
close(inpipe[0]); |
||||
|
run_child(outpipe[0], inpipe[1]); |
||||
|
} |
||||
|
|
||||
|
if (batch->child_pid == -1) |
||||
|
goto cleanup_pid; |
||||
|
|
||||
|
close(outpipe[0]); |
||||
|
close(inpipe[1]); |
||||
|
|
||||
|
batch->to_child = outpipe[1]; |
||||
|
batch->from_child = inpipe[0]; |
||||
|
return true; |
||||
|
|
||||
|
cleanup_pid: |
||||
|
batch->child_pid = 0; |
||||
|
close_noerr(inpipe[0]); |
||||
|
close_noerr(inpipe[1]); |
||||
|
close_outpipe: |
||||
|
close_noerr(outpipe[0]); |
||||
|
close_noerr(outpipe[1]); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
static bool check_with_child(struct ptr_valid_batch *batch, |
||||
|
const void *p, size_t size, bool is_write) |
||||
|
{ |
||||
|
char ret; |
||||
|
|
||||
|
if (!child_alive(batch)) { |
||||
|
if (!create_child(batch)) |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
if (write(batch->to_child, &p, sizeof(p)) |
||||
|
+ write(batch->to_child, &size, sizeof(size)) |
||||
|
+ write(batch->to_child, &is_write, sizeof(is_write)) |
||||
|
!= sizeof(p) + sizeof(size) + sizeof(is_write)) { |
||||
|
finish_child(batch); |
||||
|
errno = EFAULT; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
if (read(batch->from_child, &ret, sizeof(ret)) != sizeof(ret)) { |
||||
|
finish_child(batch); |
||||
|
errno = EFAULT; |
||||
|
return false; |
||||
|
} |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
/* msync seems most well-defined test, but page could be mapped with
|
||||
|
* no permissions, and can't distiguish readonly from writable. */ |
||||
|
bool ptr_valid_batch(struct ptr_valid_batch *batch, |
||||
|
const void *p, size_t alignment, size_t size, bool write) |
||||
|
{ |
||||
|
char *start, *end; |
||||
|
bool ret; |
||||
|
|
||||
|
if ((intptr_t)p & (alignment - 1)) |
||||
|
return false; |
||||
|
|
||||
|
start = (void *)((intptr_t)p & ~(getpagesize() - 1)); |
||||
|
end = (void *)(((intptr_t)p + size - 1) & ~(getpagesize() - 1)); |
||||
|
|
||||
|
/* We cache single page hits. */ |
||||
|
if (start == end) { |
||||
|
if (batch->last && batch->last == start) |
||||
|
return batch->last_ok; |
||||
|
} |
||||
|
|
||||
|
if (batch->num_maps) |
||||
|
ret = check_with_maps(batch, p, size, write); |
||||
|
else |
||||
|
ret = check_with_child(batch, p, size, write); |
||||
|
|
||||
|
if (start == end) { |
||||
|
batch->last = start; |
||||
|
batch->last_ok = ret; |
||||
|
} |
||||
|
|
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
bool ptr_valid_batch_string(struct ptr_valid_batch *batch, const char *p) |
||||
|
{ |
||||
|
while (ptr_valid_batch(batch, p, 1, 1, false)) { |
||||
|
if (*p == '\0') |
||||
|
return true; |
||||
|
p++; |
||||
|
} |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
bool ptr_valid(const void *p, size_t alignment, size_t size, bool write) |
||||
|
{ |
||||
|
bool ret; |
||||
|
struct ptr_valid_batch batch; |
||||
|
if (!ptr_valid_batch_start(&batch)) |
||||
|
return false; |
||||
|
ret = ptr_valid_batch(&batch, p, alignment, size, write); |
||||
|
ptr_valid_batch_end(&batch); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
bool ptr_valid_string(const char *p) |
||||
|
{ |
||||
|
bool ret; |
||||
|
struct ptr_valid_batch batch; |
||||
|
if (!ptr_valid_batch_start(&batch)) |
||||
|
return false; |
||||
|
ret = ptr_valid_batch_string(&batch, p); |
||||
|
ptr_valid_batch_end(&batch); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
bool ptr_valid_batch_start(struct ptr_valid_batch *batch) |
||||
|
{ |
||||
|
batch->child_pid = 0; |
||||
|
batch->maps = get_proc_maps(&batch->num_maps); |
||||
|
batch->last = NULL; |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
void ptr_valid_batch_end(struct ptr_valid_batch *batch) |
||||
|
{ |
||||
|
if (child_alive(batch)) |
||||
|
finish_child(batch); |
||||
|
free(batch->maps); |
||||
|
} |
||||
@ -0,0 +1,229 @@ |
|||||
|
// Licensed under BSD-MIT: See LICENSE.
|
||||
|
#ifndef CCAN_PTR_VALID_H |
||||
|
#define CCAN_PTR_VALID_H |
||||
|
#include "config.h" |
||||
|
#include <stdbool.h> |
||||
|
#include <stdlib.h> |
||||
|
|
||||
|
/**
|
||||
|
* ptr_valid_read - can I safely read from a pointer? |
||||
|
* @p: the proposed pointer. |
||||
|
* |
||||
|
* This function verifies that the pointer @p is safe to dereference for |
||||
|
* reading. It is very slow, particularly if the answer is "no". |
||||
|
* |
||||
|
* Sets errno to EFAULT on failure. |
||||
|
* |
||||
|
* See Also: |
||||
|
* ptr_valid_batch_read() |
||||
|
*/ |
||||
|
#define ptr_valid_read(p) \ |
||||
|
ptr_valid_r((p), PTR_VALID_ALIGNOF(*(p)), sizeof(*(p))) |
||||
|
|
||||
|
/**
|
||||
|
* ptr_valid_write - can I safely write to a pointer? |
||||
|
* @p: the proposed pointer. |
||||
|
* |
||||
|
* This function verifies that the pointer @p is safe to dereference |
||||
|
* for writing (and reading). It is very slow, particularly if the |
||||
|
* answer is "no". |
||||
|
* |
||||
|
* Sets errno to EFAULT on failure. |
||||
|
* |
||||
|
* See Also: |
||||
|
* ptr_valid_batch_write() |
||||
|
*/ |
||||
|
#define ptr_valid_write(p) \ |
||||
|
ptr_valid_w((p), PTR_VALID_ALIGNOF(*(p)), sizeof(*(p))) |
||||
|
|
||||
|
/**
|
||||
|
* ptr_valid_string - can I safely read a string? |
||||
|
* @p: the proposed string. |
||||
|
* |
||||
|
* This function verifies that the pointer @p is safe to dereference |
||||
|
* up to a nul character. It is very slow, particularly if the answer |
||||
|
* is "no". |
||||
|
* |
||||
|
* Sets errno to EFAULT on failure. |
||||
|
* |
||||
|
* See Also: |
||||
|
* ptr_valid_batch_string() |
||||
|
*/ |
||||
|
bool ptr_valid_string(const char *p); |
||||
|
|
||||
|
/**
|
||||
|
* ptr_valid - generic pointer check function |
||||
|
* @p: the proposed pointer. |
||||
|
* @align: the alignment requirements of the pointer. |
||||
|
* @size: the size of the region @p should point to |
||||
|
* @write: true if @p should be writable as well as readable. |
||||
|
* |
||||
|
* This function verifies that the pointer @p is safe to dereference. |
||||
|
* It is very slow, particularly if the answer is "no". |
||||
|
* |
||||
|
* Sets errno to EFAULT on failure. |
||||
|
* |
||||
|
* See Also: |
||||
|
* ptr_valid_batch() |
||||
|
*/ |
||||
|
bool ptr_valid(const void *p, size_t align, size_t size, bool write); |
||||
|
|
||||
|
/**
|
||||
|
* struct ptr_valid_batch - pointer to store state for batch ptr ops |
||||
|
* |
||||
|
* Treat as private. |
||||
|
*/ |
||||
|
struct ptr_valid_batch { |
||||
|
unsigned int num_maps; |
||||
|
struct ptr_valid_map *maps; |
||||
|
int child_pid; |
||||
|
int to_child, from_child; |
||||
|
void *last; |
||||
|
bool last_ok; |
||||
|
}; |
||||
|
|
||||
|
/**
|
||||
|
* ptr_valid_batch_start - prepare for a batch of ptr_valid checks. |
||||
|
* @batch: an uninitialized ptr_valid_batch structure. |
||||
|
* |
||||
|
* This initializes @batch; this same @batch pointer can be reused |
||||
|
* until the memory map changes (eg. via mmap(), munmap() or even |
||||
|
* malloc() and free()). |
||||
|
* |
||||
|
* This is useful to check many pointers, because otherwise it can be |
||||
|
* extremely slow. |
||||
|
* |
||||
|
* Example: |
||||
|
* struct linked { |
||||
|
* struct linked *next; |
||||
|
* const char *str; |
||||
|
* }; |
||||
|
* |
||||
|
* static bool check_linked_carefully(struct linked *head) |
||||
|
* { |
||||
|
* struct ptr_valid_batch batch; |
||||
|
* struct linked *old = head; |
||||
|
* bool half = true; |
||||
|
* |
||||
|
* // If this fails, we can't check. Assume OK.
|
||||
|
* if (!ptr_valid_batch_start(&batch)) |
||||
|
* return true; |
||||
|
* |
||||
|
* while (head) { |
||||
|
* if (!ptr_valid_batch_read(&batch, head)) |
||||
|
* goto fail; |
||||
|
* if (!ptr_valid_batch_string(&batch, head->str)) |
||||
|
* goto fail; |
||||
|
* // Loop detection; move old at half speed of head.
|
||||
|
* if (half) |
||||
|
* old = old->next; |
||||
|
* half = !half; |
||||
|
* if (head == old) { |
||||
|
* errno = ELOOP; |
||||
|
* goto fail; |
||||
|
* } |
||||
|
* } |
||||
|
* ptr_valid_batch_end(&batch); |
||||
|
* return true; |
||||
|
* |
||||
|
* fail: |
||||
|
* ptr_valid_batch_end(&batch); |
||||
|
* return false; |
||||
|
* } |
||||
|
* |
||||
|
* See Also: |
||||
|
* ptr_valid_batch_stop() |
||||
|
*/ |
||||
|
bool ptr_valid_batch_start(struct ptr_valid_batch *batch); |
||||
|
|
||||
|
/**
|
||||
|
* ptr_valid_batch_read - can I safely read from a pointer? |
||||
|
* @batch: the batch initialized by ptr_valid_batch_start(). |
||||
|
* @p: the proposed pointer. |
||||
|
* |
||||
|
* Batched version of ptr_valid_read(). |
||||
|
*/ |
||||
|
#define ptr_valid_batch_read(batch, p) \ |
||||
|
ptr_valid_batch_r((batch), \ |
||||
|
(p), PTR_VALID_ALIGNOF(*(p)), sizeof(*(p))) |
||||
|
|
||||
|
/**
|
||||
|
* ptr_valid_batch_write - can I safely write to a pointer? |
||||
|
* @batch: the batch initialized by ptr_valid_batch_start(). |
||||
|
* @p: the proposed pointer. |
||||
|
* |
||||
|
* Batched version of ptr_valid_write(). |
||||
|
*/ |
||||
|
#define ptr_valid_batch_write(batch, p) \ |
||||
|
ptr_valid_batch_w((batch), \ |
||||
|
(p), PTR_VALID_ALIGNOF(*(p)), sizeof(*(p))) |
||||
|
|
||||
|
/**
|
||||
|
* ptr_valid_batch_string - can I safely read a string? |
||||
|
* @batch: the batch initialized by ptr_valid_batch_start(). |
||||
|
* @p: the proposed string. |
||||
|
* |
||||
|
* Batched version of ptr_valid_string(). |
||||
|
*/ |
||||
|
bool ptr_valid_batch_string(struct ptr_valid_batch *batch, const char *p); |
||||
|
|
||||
|
/**
|
||||
|
* ptr_valid_batch - generic batched pointer check function |
||||
|
* @batch: the batch initialized by ptr_valid_batch_start(). |
||||
|
* @p: the proposed pointer. |
||||
|
* @align: the alignment requirements of the pointer. |
||||
|
* @size: the size of the region @p should point to |
||||
|
* @write: true if @p should be writable as well as readable. |
||||
|
* |
||||
|
* Batched version of ptr_valid(). |
||||
|
*/ |
||||
|
bool ptr_valid_batch(struct ptr_valid_batch *batch, |
||||
|
const void *p, size_t alignment, size_t size, bool write); |
||||
|
|
||||
|
/**
|
||||
|
* ptr_valid_batch_end - end a batch of ptr_valid checks. |
||||
|
* @batch: a ptr_valid_batch structure. |
||||
|
* |
||||
|
* This is used after all checks are complete. |
||||
|
* |
||||
|
* See Also: |
||||
|
* ptr_valid_batch_start() |
||||
|
*/ |
||||
|
void ptr_valid_batch_end(struct ptr_valid_batch *batch); |
||||
|
|
||||
|
|
||||
|
/* These wrappers get constness correct. */ |
||||
|
static inline bool ptr_valid_r(const void *p, size_t align, size_t size) |
||||
|
{ |
||||
|
return ptr_valid(p, align, size, false); |
||||
|
} |
||||
|
|
||||
|
static inline bool ptr_valid_w(void *p, size_t align, size_t size) |
||||
|
{ |
||||
|
return ptr_valid(p, align, size, true); |
||||
|
} |
||||
|
|
||||
|
static inline bool ptr_valid_batch_r(struct ptr_valid_batch *batch, |
||||
|
const void *p, size_t align, size_t size) |
||||
|
{ |
||||
|
return ptr_valid_batch(batch, p, align, size, false); |
||||
|
} |
||||
|
|
||||
|
static inline bool ptr_valid_batch_w(struct ptr_valid_batch *batch, |
||||
|
void *p, size_t align, size_t size) |
||||
|
{ |
||||
|
return ptr_valid_batch(batch, p, align, size, true); |
||||
|
} |
||||
|
|
||||
|
struct ptr_valid_map { |
||||
|
const char *start, *end; |
||||
|
bool is_write; |
||||
|
}; |
||||
|
|
||||
|
#if HAVE_ALIGNOF |
||||
|
#define PTR_VALID_ALIGNOF(var) __alignof__(var) |
||||
|
#else |
||||
|
/* Can't check this... */ |
||||
|
#define PTR_VALID_ALIGNOF(var) 1 |
||||
|
#endif |
||||
|
#endif /* CCAN_PTR_VALID_H */ |
||||
@ -0,0 +1,56 @@ |
|||||
|
#include <ccan/ptr_valid/ptr_valid.h> |
||||
|
/* Include the C files directly. */ |
||||
|
#include <ccan/ptr_valid/ptr_valid.c> |
||||
|
#include <ccan/tap/tap.h> |
||||
|
#include <sys/mman.h> |
||||
|
|
||||
|
int main(void) |
||||
|
{ |
||||
|
char *page; |
||||
|
struct ptr_valid_batch *batch = malloc(sizeof *batch); |
||||
|
|
||||
|
/* This is how many tests you plan to run */ |
||||
|
plan_tests(14); |
||||
|
|
||||
|
page = mmap(NULL, getpagesize(), PROT_READ|PROT_WRITE, |
||||
|
MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); |
||||
|
strcpy(page, "hello"); |
||||
|
ok1(ptr_valid_read(page)); |
||||
|
ok1(ptr_valid_write(page)); |
||||
|
ok1(ptr_valid_string(page)); |
||||
|
|
||||
|
ok1(ptr_valid_batch_start(batch)); |
||||
|
ok1(ptr_valid_batch_string(batch, page)); |
||||
|
ptr_valid_batch_end(batch); |
||||
|
|
||||
|
/* Check invalid case. */ |
||||
|
munmap(page, getpagesize()); |
||||
|
ok1(!ptr_valid_string(page)); |
||||
|
|
||||
|
ok1(ptr_valid_batch_start(batch)); |
||||
|
ok1(!ptr_valid_batch_string(batch, page)); |
||||
|
ptr_valid_batch_end(batch); |
||||
|
|
||||
|
/* Check for overrun. */ |
||||
|
page = mmap(NULL, getpagesize()*2, PROT_READ|PROT_WRITE, |
||||
|
MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); |
||||
|
munmap(page + getpagesize(), getpagesize()); |
||||
|
|
||||
|
memset(page, 'a', getpagesize()); |
||||
|
ok1(!ptr_valid_string(page)); |
||||
|
ok1(ptr_valid_batch_start(batch)); |
||||
|
ok1(!ptr_valid_batch_string(batch, page)); |
||||
|
ptr_valid_batch_end(batch); |
||||
|
|
||||
|
page[getpagesize()-1] = '\0'; |
||||
|
ok1(ptr_valid_string(page)); |
||||
|
|
||||
|
ok1(ptr_valid_batch_start(batch)); |
||||
|
ok1(ptr_valid_batch_string(batch, page)); |
||||
|
ptr_valid_batch_end(batch); |
||||
|
munmap(page, getpagesize()); |
||||
|
|
||||
|
free(batch); |
||||
|
/* This exits depending on whether all tests passed */ |
||||
|
return exit_status(); |
||||
|
} |
||||
@ -0,0 +1,90 @@ |
|||||
|
#include <ccan/ptr_valid/ptr_valid.h> |
||||
|
/* Include the C files directly. */ |
||||
|
#include <ccan/ptr_valid/ptr_valid.c> |
||||
|
#include <ccan/tap/tap.h> |
||||
|
#include <sys/mman.h> |
||||
|
|
||||
|
static bool check_batch(char *p, unsigned int num, bool expect) |
||||
|
{ |
||||
|
struct ptr_valid_batch batch; |
||||
|
unsigned int i; |
||||
|
|
||||
|
if (!ptr_valid_batch_start(&batch)) |
||||
|
return false; |
||||
|
for (i = 0; i < num; i++) { |
||||
|
if (ptr_valid_batch(&batch, p + i, 1, 1, false) != expect) |
||||
|
return false; |
||||
|
if (ptr_valid_batch(&batch, p + i, 1, 1, true) != expect) |
||||
|
return false; |
||||
|
} |
||||
|
ptr_valid_batch_end(&batch); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
int main(void) |
||||
|
{ |
||||
|
char *page; |
||||
|
|
||||
|
/* This is how many tests you plan to run */ |
||||
|
plan_tests(30); |
||||
|
|
||||
|
page = mmap(NULL, getpagesize(), PROT_READ|PROT_WRITE, |
||||
|
MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); |
||||
|
ok1(ptr_valid_read(page)); |
||||
|
ok1(ptr_valid_write(page)); |
||||
|
ok1(ptr_valid(page, 1, getpagesize(), false)); |
||||
|
ok1(ptr_valid(page, 1, getpagesize(), true)); |
||||
|
|
||||
|
/* Test alignment constraints. */ |
||||
|
ok1(ptr_valid(page, getpagesize(), getpagesize(), false)); |
||||
|
ok1(ptr_valid(page, getpagesize(), getpagesize(), true)); |
||||
|
ok1(!ptr_valid(page+1, getpagesize(), 1, false)); |
||||
|
ok1(!ptr_valid(page+1, getpagesize(), 1, true)); |
||||
|
|
||||
|
/* Test batch. */ |
||||
|
ok1(check_batch(page, getpagesize(), true)); |
||||
|
|
||||
|
/* Unmap, all should fail. */ |
||||
|
munmap(page, getpagesize()); |
||||
|
ok1(!ptr_valid_read(page)); |
||||
|
ok1(!ptr_valid_write(page)); |
||||
|
ok1(!ptr_valid(page, 1, getpagesize(), false)); |
||||
|
ok1(!ptr_valid(page, 1, getpagesize(), true)); |
||||
|
|
||||
|
/* Test alignment constraints. */ |
||||
|
ok1(!ptr_valid(page, getpagesize(), getpagesize(), false)); |
||||
|
ok1(!ptr_valid(page, getpagesize(), getpagesize(), true)); |
||||
|
ok1(!ptr_valid(page+1, getpagesize(), 1, false)); |
||||
|
ok1(!ptr_valid(page, getpagesize(), 1, true)); |
||||
|
|
||||
|
/* Test batch (slow, since each fails, so reduce count). */ |
||||
|
ok1(check_batch(page, 4, false)); |
||||
|
|
||||
|
/* Check read-only */ |
||||
|
page = mmap(NULL, getpagesize(), PROT_READ, |
||||
|
MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); |
||||
|
ok1(ptr_valid_read(page)); |
||||
|
ok1(!ptr_valid_write(page)); |
||||
|
ok1(ptr_valid(page, 1, getpagesize(), false)); |
||||
|
ok1(!ptr_valid(page, 1, getpagesize(), true)); |
||||
|
|
||||
|
/* Test alignment constraints. */ |
||||
|
ok1(ptr_valid(page, getpagesize(), getpagesize(), false)); |
||||
|
ok1(!ptr_valid(page, getpagesize(), getpagesize(), true)); |
||||
|
ok1(!ptr_valid(page+1, getpagesize(), 1, false)); |
||||
|
ok1(!ptr_valid(page+1, getpagesize(), 1, true)); |
||||
|
munmap(page, getpagesize()); |
||||
|
|
||||
|
/* Check for overrun. */ |
||||
|
page = mmap(NULL, getpagesize()*2, PROT_READ|PROT_WRITE, |
||||
|
MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); |
||||
|
munmap(page + getpagesize(), getpagesize()); |
||||
|
|
||||
|
ok1(ptr_valid(page, 1, getpagesize(), false)); |
||||
|
ok1(ptr_valid(page, 1, getpagesize(), true)); |
||||
|
ok1(!ptr_valid(page, 1, getpagesize()+1, false)); |
||||
|
ok1(!ptr_valid(page, 1, getpagesize()+1, true)); |
||||
|
|
||||
|
/* This exits depending on whether all tests passed */ |
||||
|
return exit_status(); |
||||
|
} |
||||
@ -0,0 +1,38 @@ |
|||||
|
#include <ccan/tal/tal.h> |
||||
|
#include <ccan/tal/tal.c> |
||||
|
#include <ccan/tap/tap.h> |
||||
|
|
||||
|
static void destroy_inc(char *p UNNEEDED, int *destroy_count) |
||||
|
{ |
||||
|
(*destroy_count)++; |
||||
|
} |
||||
|
|
||||
|
static void destroy_dec(char *p UNNEEDED, int *destroy_count) |
||||
|
{ |
||||
|
(*destroy_count)--; |
||||
|
} |
||||
|
|
||||
|
int main(void) |
||||
|
{ |
||||
|
char *p; |
||||
|
int destroy_count1 = 0, destroy_count2 = 0; |
||||
|
|
||||
|
plan_tests(10); |
||||
|
|
||||
|
p = tal(NULL, char); |
||||
|
/* Del must match both fn and arg. */ |
||||
|
ok1(tal_add_destructor2(p, destroy_inc, &destroy_count1)); |
||||
|
ok1(!tal_del_destructor2(p, destroy_inc, &destroy_count2)); |
||||
|
ok1(!tal_del_destructor2(p, destroy_dec, &destroy_count1)); |
||||
|
ok1(tal_del_destructor2(p, destroy_inc, &destroy_count1)); |
||||
|
ok1(!tal_del_destructor2(p, destroy_inc, &destroy_count1)); |
||||
|
|
||||
|
ok1(tal_add_destructor2(p, destroy_inc, &destroy_count1)); |
||||
|
ok1(tal_add_destructor2(p, destroy_dec, &destroy_count2)); |
||||
|
ok1(tal_free(p) == NULL); |
||||
|
ok1(destroy_count1 == 1); |
||||
|
ok1(destroy_count2 == -1); |
||||
|
|
||||
|
tal_cleanup(); |
||||
|
return exit_status(); |
||||
|
} |
||||
Loading…
Reference in new issue