├── .travis.yml
├── .gitignore
├── .dir-locals.el
├── compiler.c
├── examples
    └── htlc
├── oplookup.h
├── util.h
├── default.nix
├── consts.h
├── deps
    └── tap.c
    │   ├── package.json
    │   ├── tap.h
    │   └── tap.c
├── test
    ├── run
    └── tests.csv
├── oplookup.c
├── alloc.h
├── doc
    └── TODO.org
├── script_num.h
├── README.md
├── script.h
├── val.h
├── lexer.l
├── LICENSE
├── misc.h
├── opcodes
├── parser.y
├── Makefile
├── valstack.h
├── compiler.h
├── stack.h
├── stack.c
├── btcs.1
├── alloc.c
├── util.c
├── val.c
├── mph-opcodes
├── ripemd160.h
├── sha256.h
├── script_num.c
├── op.h
├── main.c
├── test.c
├── endian.h
├── sha256.c
├── op.c
├── ripemd160.c
└── script.c


/.travis.yml:
--------------------------------------------------------------------------------
1 | language: c
2 | script: make && make check
3 | compiler:
4 |   - clang
5 |   - gcc
6 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.o
2 | /parser.tab.h
3 | /parser.tab.c
4 | /lex.yy.c
5 | /btcs
6 | /TAGS
7 | *.d
8 | /run_tests
9 | 


--------------------------------------------------------------------------------
/.dir-locals.el:
--------------------------------------------------------------------------------
1 | ((c-mode . ((c-file-style . "linux")
2 |             (indent-tabs-mode . t)
3 |             (show-trailing-whitespace . t)
4 |             (c-basic-offset . 8)
5 |             (tab-width . 8)
6 |             ))
7 |  )
8 | 


--------------------------------------------------------------------------------
/compiler.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdlib.h>
 3 | #include "compiler.h"
 4 | 
 5 | bool alignment_ok(const void *p, size_t n)
 6 | {
 7 | #if HAVE_UNALIGNED_ACCESS
 8 | 	return true;
 9 | #else
10 | 	return ((size_t)p % n == 0);
11 | #endif
12 | }
13 | 


--------------------------------------------------------------------------------
/examples/htlc:
--------------------------------------------------------------------------------
1 | OP_IF
2 |     [HASHOP] <digest> OP_EQUALVERIFY OP_DUP OP_HASH160 <seller pubkey hash>            
3 | OP_ELSE
4 |     <num> [TIMEOUTOP] OP_DROP OP_DUP OP_HASH160 <buyer pubkey hash>
5 | OP_ENDIF
6 | OP_EQUALVERIFY
7 | OP_CHECKSIG
8 | 


--------------------------------------------------------------------------------
/oplookup.h:
--------------------------------------------------------------------------------
 1 | /* THIS IS GENERATED FROM mph-opcodes DO NOT EDIT */
 2 | 
 3 | #ifndef BCS_OPLOOKUP_H
 4 | #define BCS_OPLOOKUP_H
 5 | 
 6 | #include "misc.h"
 7 | extern const int opcodes_g[120];
 8 | extern const int opcodes_v[120];
 9 | 
10 | #endif /* BCS_OPLOOKUP_H */
11 | 


--------------------------------------------------------------------------------
/util.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef BTCS_UTIL_H
 3 | #define BTCS_UTIL_H
 4 | 
 5 | #include <stdbool.h>
 6 | #include <stdlib.h>
 7 | #include <stdio.h>
 8 | #include <stdint.h>
 9 | 
10 | typedef intptr_t ssize_t;
11 | 
12 | 
13 | int read_arg_or_stdin(const char *arg, unsigned char *buf, size_t buflen, size_t *written);
14 | bool hex_decode(const char *str, size_t *slen, void *buf, size_t bufsize);
15 | ssize_t getline(char **lineptr, size_t *n, FILE *stream);
16 | 
17 | #endif /* UTIL_H */
18 | 


--------------------------------------------------------------------------------
/default.nix:
--------------------------------------------------------------------------------
 1 | { nixpkgs ? import <nixpkgs> {}
 2 | , stdenv ? nixpkgs.stdenv
 3 | , bison ? nixpkgs.bison
 4 | , lib ? nixpkgs.lib
 5 | , flex ? nixpkgs.flex
 6 | , python3 ? nixpkgs.python3
 7 | }:
 8 | 
 9 | stdenv.mkDerivation rec {
10 |   name = "btcs-${version}";
11 |   version = "0.1";
12 | 
13 |   src = ./.;
14 | 
15 |   makeFlags = ["PREFIX=$(out)"];
16 | 
17 |   nativeBuildInputs = [ bison flex python3 ];
18 | 
19 |   patchPhase = ''
20 |     patchShebangs mph-opcodes
21 |   '';
22 | 
23 |   meta = with lib; {
24 |     description = "Bitcoin script evaluator";
25 |     homepage = "https://github.com/jb55/btcs";
26 |     maintainers = with maintainers; [ jb55 ];
27 |     license = licenses.mit;
28 |   };
29 | }
30 | 


--------------------------------------------------------------------------------
/consts.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef BTCS_CONSTS_H
 3 | #define BTCS_CONSTS_H
 4 | 
 5 | // Maximum number of bytes pushable to the stack
 6 | #define MAX_SCRIPT_ELEMENT_SIZE 520
 7 | 
 8 | // Maximum number of non-push operations per script
 9 | static const int MAX_OPS_PER_SCRIPT = 201;
10 | 
11 | // Maximum number of public keys per multisig
12 | static const int MAX_PUBKEYS_PER_MULTISIG = 20;
13 | 
14 | // Maximum script length in bytes
15 | static const int MAX_SCRIPT_SIZE = 10000;
16 | 
17 | // Threshold for nLockTime: below this value it is interpreted as block number,
18 | // otherwise as UNIX timestamp.
19 | static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
20 | 
21 | 
22 | #endif /* BTCS_CONSTS_H */
23 | 


--------------------------------------------------------------------------------
/deps/tap.c/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name" : "tap.c",
 3 |     "version" : "0.0.1",
 4 |     "description" : "Write tap tests in C.",
 5 |     "src": [ "tap.c", "tap.h" ],
 6 |     "repository" : {
 7 |       "type" : "git",
 8 |       "url" : "git://github.com/thlorenz/tap.c.git"
 9 |     },
10 |     "homepage" : "https://github.com/thlorenz/tap.c",
11 |     "dependencies" : {
12 |     },
13 |     "keywords": ["tap", "test", "check", "tap.c" ] ,
14 |     "author" : {
15 |       "name" : "Thorsten Lorenz",
16 |       "email" : "thlorenz@gmx.de",
17 |       "url" : "http://thlorenz.com"
18 |     },
19 |     "license" : {
20 |       "type": "GPLv2",
21 |       "url": "https://github.com/thlorenz/tap.c/blob/master/COPYING"
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/test/run:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | process () {
 4 |     tail -n+2 "$1" | sed -n '/^--- failing/q;p'
 5 | }
 6 | 
 7 | n=1
 8 | c=$(($(process tests.csv | wc -l)))
 9 | 
10 | printf "1..%d\n" "$c"
11 | 
12 | process tests.csv | \
13 | (fail=0
14 | while IFS=, read -r description args input expected
15 | do
16 |     output=$(../btcs $args <<<"$input" 2>&1)
17 | 	output2=${output//[$'\t\r\n']/ }
18 |     if [ "$output2" == "$expected" ]; then
19 |         printf "ok %d - %s\n" "$n" "$description"
20 |     else
21 |         printf "not ok %d - %s\n" "$n" "$description"
22 |         printf "#\n#    got      '%s', \n#    expected '%s'\n#\n" "$output2" "$expected"
23 |         fail=1
24 |     fi
25 |     n=$((n + 1))
26 | done
27 |  exit $fail
28 | )
29 | 
30 | 


--------------------------------------------------------------------------------
/oplookup.c:
--------------------------------------------------------------------------------
1 | /* THIS IS GENERATED FROM mph-opcodes DO NOT EDIT */
2 | 
3 | #include "oplookup.h"
4 | const int opcodes_g[120] = { 1,-118,0,2,-116,0,0,2,0,0,0,-114,3,-111,8,0,0,0,0,8,-110,-107,1,0,0,-101,0,-98,0,-92,0,10,1,1,0,0,0,0,-89,0,5,-88,2,-87,4,-86,-79,-78,2,0,-74,-73,-72,-70,-69,0,1,1,-63,-61,-59,-56,-55,0,0,0,-53,0,-49,0,1,-48,0,-47,0,0,2,-46,1,0,5,3,-44,-41,0,2,-38,-33,-30,14,-29,0,2,0,-28,0,-27,0,0,-26,0,0,-23,0,0,0,-20,1,-18,0,-15,-12,8,1,0,-10,10,2,6,7 };
5 | const int opcodes_v[120] = { 66,111,5,90,50,33,76,105,6,104,65,77,55,32,116,49,71,85,75,113,60,26,52,88,46,57,86,41,96,36,18,19,69,56,95,63,42,51,30,117,4,13,80,64,68,72,67,59,74,89,83,34,44,53,24,23,48,39,22,47,21,70,20,109,112,7,103,40,25,43,8,2,9,73,99,110,81,14,15,106,97,45,17,16,29,12,10,1,120,114,58,118,31,82,37,62,92,102,3,108,107,11,28,93,27,94,79,115,98,78,87,54,38,101,35,100,119,91,84,61 };
6 | 


--------------------------------------------------------------------------------
/alloc.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef BTCS_ALLOC_H
 3 | #define BTCS_ALLOC_H
 4 | 
 5 | #include "consts.h"
 6 | #include "script_num.h"
 7 | #include "misc.h"
 8 | 
 9 | // MAX_OPS_PER_SCRIPT *
10 | #define MAX_PUSHDATA_REFS (MAX_OPS_PER_SCRIPT * MAX_STACK_SIZE)
11 | #define ALLOC_PUSHDATA_BYTES (MAX_STACK_SIZE * MAX_OPS_PER_SCRIPT)
12 | 
13 | struct num * num_pool_new(u16 *ind);
14 | struct num * num_pool_pop();
15 | struct num * num_pool_get(const u16 ind);
16 | 
17 | u8 *byte_pool_new(u32 len, u16 *ind);
18 | u8 *byte_pool_get(int ind, u32 *len);
19 | u8 *byte_pool_pop();
20 | 
21 | struct arenas {
22 |   struct num *nums;
23 |   u8 *bytes;
24 |   u8 *bytes_top;
25 |   struct stack bytes_map;
26 |   int nbytes;
27 |   int num_count;
28 | };
29 | 
30 | void alloc_arena_sizes(struct arenas *, const int nums, const int bytes);
31 | void alloc_arenas();
32 | void free_arenas(struct arenas *arenas);
33 | 
34 | #endif /* BTCS_ALLOC_H */
35 | 


--------------------------------------------------------------------------------
/doc/TODO.org:
--------------------------------------------------------------------------------
 1 | 
 2 | * Suggestions
 3 | 
 4 | `arubi` from #bitcoin-dev
 5 | 
 6 |     10:44 <arubi> jb55, awesome. for my serializer, I also defined a few "make
 7 |     your life easy" templates, like plain numbers are treated as scriptnum (need
 8 |     to be valid), the character @ means minimal push, so something like @<hex
 9 |     pubkey> is converted to 0x21 0x<pubkey> (and longer pushes if needed), a
10 |     0x<hex> is just treated like literal serialized part of the script.. you're
11 |     probably already on it, but just my pov :)
12 |     
13 |     11:16 <arubi> the behavior is pretty similar really, segwit serializes the
14 |     codesep while legacy doesn't. segwit makes checksig ops a lot easier because
15 |     of the better sighash scheme in bip143. there are so many interesting
16 |     sighash types, and there are probably going to be more eventually, that
17 |     implementing legacy just seems like a waste of time now
18 |     
19 | * Remaining OPCODES
20 | 


--------------------------------------------------------------------------------
/script_num.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef BTCS_SCRIPTNUM_H
 3 | #define BTCS_SCRIPTNUM_H
 4 | 
 5 | #include "misc.h"
 6 | #include "val.h"
 7 | 
 8 | enum sn_result {
 9 |   SN_SUCCESS,
10 |   SN_ERR_OVERFLOWED_INT
11 | };
12 | 
13 | struct num {
14 |   s64 val;
15 |   int ind;
16 | };
17 | 
18 | void
19 | sn_from_int(s64 n, struct num *);
20 | 
21 | int
22 | sn_overflowed(struct num *num);
23 | 
24 | enum sn_result
25 | sn_from_val(struct val val, struct num ** sn);
26 | 
27 | struct val
28 | sn_to_val(struct num *sn);
29 | 
30 | int
31 | sn_to_int(struct num *sn, int require_minimal);
32 | 
33 | void
34 | sn_serialize(struct num *sn, u8 *buf, int bufsize, u16 *len);
35 | 
36 | 
37 | inline static void sn_add(struct num *a, struct num *b, struct num *c) {
38 |   c->val = a->val + b->val;
39 | }
40 | 
41 | inline static void sn_sub(struct num *a, struct num *b, struct num *c) {
42 |   c->val = a->val - b->val;
43 | }
44 | 
45 | inline static void sn_neg(struct num *a, struct num *b) {
46 |   b->val = -(a->val);
47 | }
48 | 
49 | 
50 | #endif /* BTCS_SCRIPTNUM_H */
51 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # btcs
 3 | 
 4 | [![Build Status](https://travis-ci.org/jb55/btcs.svg)](https://travis-ci.org/jb55/btcs)
 5 | 
 6 |   bitcoin script parser/evaluator/compiler/decompiler
 7 | 
 8 |   **WARNING**: This is not a consensus-critical implementation of
 9 |   bitcoin script. Make sure to actually test your script on testnet or
10 |   with something like [btcdeb](https://github.com/kallewoof/btcdeb).
11 | 
12 | ## Motivation
13 | 
14 |   I wanted a better way to hack on Bitcoin scripts
15 | 
16 | ## Installing
17 | 
18 | deps: `python3`, `bison`, `flex`, a C compiler
19 | 
20 |     $ make install
21 | 
22 | with nix:
23 | 
24 |     $ nix-env -if .
25 | 
26 | ## TODOs
27 | 
28 | - [X] Tokenizer
29 | - [ ] Evaluator (partially complete)
30 | - [X] Compiler
31 | - [X] Decompiler
32 | - [X] Docs
33 | 
34 | ## Usage
35 | 
36 |   Work in progress. Some OPs are working:
37 | 
38 | ```
39 | $ btcs 1 2 16 3dup 2swap
40 | 
41 | script      1 2 16 OP_3DUP OP_2SWAP
42 | script_hex  5152606f72
43 | stack       1 2 2 16 16 1
44 | stack_hex   010202101001
45 | results     success
46 | ```
47 | 


--------------------------------------------------------------------------------
/script.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef BTCS_SCRIPT_H
 3 | #define BTCS_SCRIPT_H
 4 | 
 5 | #include "stack.h"
 6 | #include "op.h"
 7 | 
 8 | struct result {
 9 |   char * error;
10 |   enum opcode last_op;
11 |   int op_count;
12 | };
13 | 
14 | int   script_eval(const u8 *script, size_t script_size, struct stack *stack,
15 |                   struct result *result);
16 | void  script_print_ops(char * buf, size_t size);
17 | void  script_print_vals(struct stack *);
18 | void  script_push_int(struct stack *, s64);
19 | 
20 | void  script_push_str(struct stack *script, const char *str);
21 | void  script_push_raw(struct stack *, const char *str);
22 | void  script_push_datastr(struct stack *, const char *str, int israw);
23 | 
24 | void script_serialize(struct stack *stack, u8 *buf, int buflen, int* len);
25 | void stack_serialize(struct stack *stack, u8 *buf, int buflen, int* len);
26 | 
27 | void script_print(const u8 *script, size_t script_size, int abbrev_data);
28 | int script_getop(const u8 **p, const u8 *end, enum opcode *popcode, u8 *buf, int bufsize, u32 *outlen);
29 | 
30 | extern int g_silence_script_err;
31 | extern int g_silence_script_warn;
32 | 
33 | #endif /* BTCS_SCRIPT_H */
34 | 


--------------------------------------------------------------------------------
/val.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef BTCS_VAL_H
 3 | #define BTCS_VAL_H
 4 | 
 5 | #include "misc.h"
 6 | #include "stack.h"
 7 | 
 8 | enum valtype {
 9 | 	VT_SCRIPTNUM=0,
10 | 	VT_SMALLINT,
11 | 	VT_OP,
12 | 	VT_RAW,
13 | 	VT_DATA,
14 | 	VT_N
15 | };
16 | // UPDATE VAL_TYPE_BITS if you need more valtypes
17 | 
18 | 
19 | #define VAL_TYPE_BITS 3
20 | /* static const int COMPACT_VAL_BITS = (32-VAL_TYPE_BITS-1); */
21 | #define VAL_COMPACT_BITS 29
22 | 
23 | struct val {
24 | 	u8 type : VAL_TYPE_BITS;
25 | 	int ind : VAL_COMPACT_BITS;
26 | };
27 | 
28 | #define smallintval(n) ((struct val){ .type = VT_SMALLINT, .ind = n })
29 | #define falseval smallintval(0)
30 | #define trueval  smallintval(1)
31 | 
32 | // we want val to fit into the size of a 32-bit pointer
33 | STATIC_ASSERT(sizeof(struct val) <= 4, val_doesnt_fit_in_stack);
34 | 
35 | struct val val_copy(struct val a);
36 | u32 val_size(struct val val);
37 | 
38 | int
39 | val_eq(struct val a, struct val b);
40 | 
41 | void val_serialize(struct val val, u32 *len, u8 *buf, int bufsize);
42 | void val_bytes(struct val val, u32 *len, u8 *buf, int bufsize);
43 | struct val val_cat(struct val a, struct val b);
44 | 
45 | struct val val_from_int(s64);
46 | 
47 | #endif /* BTCS_VAL_H */
48 | 


--------------------------------------------------------------------------------
/lexer.l:
--------------------------------------------------------------------------------
 1 | %option noyywrap
 2 | 
 3 | %{
 4 | #include <stdio.h>
 5 | #include "script.h"
 6 | #include "op.h"
 7 | 
 8 | int fileno(FILE *stream);
 9 | #define YY_DECL int yylex()
10 | 
11 | #include "parser.tab.h"
12 | 
13 | %}
14 | 
15 | %%
16 | 
17 | [ \t]	; // ignore all whitespace
18 | \n		{return T_NEWLINE;}
19 | 
20 | \<[^\>]+\> { yylval.str = yytext; return T_EXAMPLE; }
21 | 
22 | \[[^\]]+\] { yylval.str = yytext; return T_EXAMPLE; }
23 | 
24 | #[^\n]* { return T_COMMENT; }
25 | 
26 | [oO][pP]_ {}
27 | 
28 | \"[^\"]*\" {
29 |   char *t = yytext + 1;
30 |   t[strlen(t) - 1] = '\0';
31 |   yylval.str = t;
32 |   return T_STR;
33 | }
34 | 
35 | 0x[a-fA-F0-9]+ {
36 |   char * t = yytext + 2;
37 |   if (strlen(t) % 2 != 0) {
38 |      yylval.str = "Invalid raw string, it must have even length";
39 |      return T_ERR;
40 |   }
41 |   yylval.str = t;
42 |   return T_RAW;
43 | }
44 | 
45 | @[a-fA-F0-9]+ {
46 |   char *t = yytext + 1;
47 |   if (strlen(t) % 2 != 0) {
48 |     yylval.str = "Invalid data string, it must have even length";
49 |     return T_ERR;
50 |   }
51 |   yylval.str = t;
52 |   return T_DATA;
53 | }
54 | 
55 | -?[0-9]+ {
56 |   s64 i = strtoll(yytext, NULL, 10);
57 |   yylval.val = val_from_int(i);
58 |   return T_VAL;
59 | }
60 | 
61 | [a-zA-Z0-9]+ {
62 |   yylval.opcode = op_tokenize(yytext);
63 |   return T_OP;
64 | }
65 | 
66 | %%
67 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2017, William Casarin
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 | 
 7 | 1. Redistributions of source code must retain the above copyright notice, this
 8 |    list of conditions and the following disclaimer.
 9 | 2. Redistributions in binary form must reproduce the above copyright notice,
10 |    this list of conditions and the following disclaimer in the documentation
11 |    and/or other materials provided with the distribution.
12 | 
13 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
14 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
17 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
20 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


--------------------------------------------------------------------------------
/misc.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef BCS_MISC_H
 3 | #define BCS_MISC_H
 4 | 
 5 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 6 | 
 7 | /* #include <endian.h> */
 8 | #include <string.h>
 9 | #include <stdint.h>
10 | #include <stdio.h>
11 | 
12 | #define DEBUG 0
13 | 
14 | enum compiler_options {
15 |   CO_WARNINGS_ARE_ERRORS = 1 << 1,
16 |   CO_WARN_MINIMAL = 1 << 2
17 | };
18 | 
19 | 
20 | /* #define debug(fmt, ...) \ */
21 | /*   do { if (DEBUG) fprintf(stderr, fmt, __VA_ARGS__); } while (0) */
22 | 
23 | typedef unsigned char  u8;
24 | typedef unsigned short u16;
25 | typedef unsigned int   u32;
26 | typedef int64_t        s64;
27 | typedef uint64_t       u64;
28 | 
29 | #define STATIC_ASSERT(COND,MSG) typedef char static_assertion_##MSG[(!!(COND))*2-1]
30 | 
31 | // TODO: host endianness
32 | #define le16toh(x) (x)
33 | #define le32toh(x) (x)
34 | 
35 | inline static u16
36 | readle16(const u8* ptr) {
37 |   u16 x;
38 |   memcpy((char*)&x, ptr, 2);
39 |   return le16toh(x);
40 | }
41 | 
42 | inline static u32
43 | readle32(const u8* ptr) {
44 |   u32 x;
45 |   memcpy((char*)&x, ptr, 4);
46 |   return le32toh(x);
47 | }
48 | 
49 | inline static void
50 | print_bytes(u8 *bytes, size_t size, int with_space) {
51 |   size_t i;
52 |   for (i = 0; i < size; i++) {
53 |     printf("%02x", bytes[i]);
54 |     if (with_space) printf(" ");
55 |   }
56 | }
57 | 
58 | 
59 | #endif /* BCS_MISC_H */
60 | 


--------------------------------------------------------------------------------
/opcodes:
--------------------------------------------------------------------------------
  1 | 0
  2 | FALSE
  3 | PUSHDATA1
  4 | PUSHDATA2
  5 | PUSHDATA4
  6 | 1NEGATE
  7 | RESERVED
  8 | 1
  9 | TRUE
 10 | 2
 11 | 3
 12 | 4
 13 | 5
 14 | 6
 15 | 7
 16 | 8
 17 | 9
 18 | 10
 19 | 11
 20 | 12
 21 | 13
 22 | 14
 23 | 15
 24 | 16
 25 | NOP
 26 | VER
 27 | IF
 28 | NOTIF
 29 | VERIF
 30 | VERNOTIF
 31 | ELSE
 32 | ENDIF
 33 | VERIFY
 34 | RETURN
 35 | TOALTSTACK
 36 | FROMALTSTACK
 37 | 2DROP
 38 | 2DUP
 39 | 3DUP
 40 | 2OVER
 41 | 2ROT
 42 | 2SWAP
 43 | IFDUP
 44 | DEPTH
 45 | DROP
 46 | DUP
 47 | NIP
 48 | OVER
 49 | PICK
 50 | ROLL
 51 | ROT
 52 | SWAP
 53 | TUCK
 54 | CAT
 55 | SUBSTR
 56 | LEFT
 57 | RIGHT
 58 | SIZE
 59 | INVERT
 60 | AND
 61 | OR
 62 | XOR
 63 | EQUAL
 64 | EQUALVERIFY
 65 | RESERVED1
 66 | RESERVED2
 67 | 1ADD
 68 | 1SUB
 69 | 2MUL
 70 | 2DIV
 71 | NEGATE
 72 | ABS
 73 | NOT
 74 | 0NOTEQUAL
 75 | ADD
 76 | SUB
 77 | MUL
 78 | DIV
 79 | MOD
 80 | LSHIFT
 81 | RSHIFT
 82 | BOOLAND
 83 | BOOLOR
 84 | NUMEQUAL
 85 | NUMEQUALVERIFY
 86 | NUMNOTEQUAL
 87 | LESSTHAN
 88 | GREATERTHAN
 89 | LESSTHANOREQUAL
 90 | GREATERTHANOREQUAL
 91 | MIN
 92 | MAX
 93 | WITHIN
 94 | RIPEMD160
 95 | SHA1
 96 | SHA256
 97 | HASH160
 98 | HASH256
 99 | CODESEPARATOR
100 | CHECKSIG
101 | CHECKSIGVERIFY
102 | CHECKMULTISIG
103 | CHECKMULTISIGVERIFY
104 | NOP1
105 | CHECKLOCKTIMEVERIFY
106 | NOP2
107 | CHECKSEQUENCEVERIFY
108 | NOP3
109 | NOP4
110 | NOP5
111 | NOP6
112 | NOP7
113 | NOP8
114 | NOP9
115 | NOP10
116 | SMALLINTEGER
117 | PUBKEYS
118 | PUBKEYHASH
119 | PUBKEY
120 | INVALIDOPCODE


--------------------------------------------------------------------------------
/parser.y:
--------------------------------------------------------------------------------
 1 | 
 2 | %{
 3 | #include <stdio.h>
 4 | #include "op.h"
 5 | #include "script.h"
 6 | #include "stack.h"
 7 | #include "valstack.h"
 8 | 
 9 | extern int yylex();
10 | extern struct stack g_reader_stack;
11 | void yyerror(const char *s);
12 | 
13 | void script_handle_input(struct stack *stack, const char *str);
14 | void parse_error(const char *err);
15 | 
16 | %}
17 | 
18 | %union {
19 |   enum opcode opcode;
20 |   s64 integer;
21 |   struct val val;
22 |   const char* str;
23 | }
24 | 
25 | %token T_OP
26 | %token T_INT
27 | %token T_VAL
28 | %token T_DATA
29 | %token T_RAW
30 | %token T_STR
31 | %token T_COMMENT
32 | %token T_ERR
33 | %token T_NEWLINE T_QUIT T_EXAMPLE
34 | 
35 | %type<opcode> T_OP
36 | %type<integer> T_INT
37 | %type<str> T_DATA
38 | %type<str> T_RAW
39 | %type<str> T_STR
40 | %type<val> T_VAL
41 | %type<str> T_EXAMPLE
42 | %type<str> T_ERR
43 | 
44 | %start script
45 | 
46 | %%
47 | 
48 | script:
49 |       | script line
50 | ;
51 | 
52 | line: T_NEWLINE
53 |     | T_COMMENT
54 |     | T_RAW     { script_push_raw(&g_reader_stack, $1); }
55 |     | T_INT     { script_push_int(&g_reader_stack, $1); }
56 |     | T_VAL     { stack_push_val(&g_reader_stack, $1); }
57 |     | T_OP      { stack_push_op(&g_reader_stack, $1); }
58 |     | T_DATA    { script_push_datastr(&g_reader_stack, $1, 0); }
59 |     | T_STR     { script_push_str(&g_reader_stack, $1); }
60 |     | T_ERR     { parse_error($1); }
61 |     | T_EXAMPLE { script_handle_input(&g_reader_stack, $1); }
62 | 
63 | 
64 | %%
65 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | CFLAGS=-g -DHAVE_LITTLE_ENDIAN -O2 -Ideps -std=c99 -Wall -Wextra -Werror -Wno-unused-variable -Wno-unused-function 
 2 | 
 3 | DEPS=script.c \
 4 |      oplookup.c \
 5 |      op.c \
 6 |      val.c \
 7 |      alloc.c \
 8 |      script_num.c \
 9 |      sha256.c \
10 |      ripemd160.c \
11 |      compiler.c \
12 |      util.c \
13 |      stack.c
14 | 
15 | CLIDEPS=parser.tab.c \
16 | 	lex.yy.c \
17 | 	main.c
18 | 
19 | # DEPS=oplookup.h script.h misc.h Makefile op.h stack.h
20 | OBJS=$(DEPS:.c=.o)
21 | CLIOBJS=$(CLIDEPS:.c=.o)
22 | 
23 | GEN=parser.tab.c \
24 |     parser.tab.h \
25 |     lex.yy.c \
26 |     oplookup.c \
27 |     oplookup.h \
28 |     $(OBJS) \
29 |     $(CLIOBJS) \
30 | 
31 | 
32 | PREFIX ?= /usr/local
33 | BIN=btcs
34 | 
35 | all: $(BIN)
36 | 
37 | include $(OBJS:.o=.d)
38 | include $(CLIOBJS:.o=.d)
39 | 
40 | op.c: oplookup.h oplookup.c
41 | 
42 | %.d: %.c
43 | 	@rm -f $@; \
44 | 	$(CC) -MM $(CFLAGS) $< > $@
45 | 
46 | oplookup.c oplookup.h: opcodes mph-opcodes
47 | 	@./mph-opcodes opcodes
48 | 
49 | parser.tab.c parser.tab.h:	parser.y
50 | 	bison -d parser.y
51 | 
52 | lex.yy.c: lexer.l parser.tab.h
53 | 	flex lexer.l
54 | 
55 | install: $(BIN)
56 | 	mkdir -p $(PREFIX)/bin
57 | 	mkdir -p $(PREFIX)/share/btcs
58 | 	cp $(BIN) $(PREFIX)/bin
59 | 	cp btcs.1 $(PREFIX)/share/btcs
60 | 
61 | $(BIN): $(OBJS) $(CLIOBJS)
62 | 	$(CC) $(CFLAGS) -o $@ $(OBJS) $(CLIOBJS)
63 | 
64 | 
65 | check: $(BIN) fake
66 | 	@sh -c "cd test && ./run"
67 | 
68 | clean: fake
69 | 	rm -f $(GEN)
70 | 	rm -f *.d
71 | 
72 | TAGS: fake
73 | 	etags -o - *.c > $@
74 | 
75 | tags: fake
76 | 	ctags *.c
77 | 
78 | .PHONY: fake
79 | 


--------------------------------------------------------------------------------
/valstack.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef BTCS_VALSTACK_H
 3 | #define BTCS_VALSTACK_H
 4 | 
 5 | #include "op.h"
 6 | #include "val.h"
 7 | #include "alloc.h"
 8 | 
 9 | static inline struct val
10 | stack_top_val(struct stack *stack, int ind) {
11 | 	struct val val;
12 | 	stack_top_small(struct val, stack, &val, ind);
13 | 	return val;
14 | }
15 | 
16 | static inline struct val
17 | stack_pop_val(struct stack *stack) {
18 | 	struct val val;
19 | 	val = stack_top_val(stack, -1);
20 | 	stack_pop(stack);
21 | 	return val;
22 | }
23 | 
24 | static inline void
25 | stack_set_val(struct stack *stack, int ind, struct val val) {
26 | 	struct val *pval = (struct val *)(stack->top + ind);
27 | 	*pval = val;
28 | }
29 | 
30 | static inline void
31 | stack_push_val(struct stack *stack, struct val val) {
32 | #if 0
33 | 	printf("pushing val ");
34 | 	val_print(val);
35 | 	printf("\n");
36 | #endif
37 | 	stack_push_small(struct val, stack, &val);
38 | }
39 | 
40 | static inline void
41 | stack_push_raw(struct stack *stack, u8 *data, int len) {
42 | 	struct val val = { .type = VT_RAW };
43 | 	u8 *p;
44 | 	u16 ind;
45 | 	p = byte_pool_new(len, &ind);
46 | 	memcpy(p, data, len);
47 | 	val.ind = ind;
48 | 	stack_push_val(stack, val);
49 | }
50 | 
51 | static inline void
52 | stack_push_op(struct stack *stack, enum opcode opcode) {
53 | 	struct val val = { .type = VT_OP, .ind = opcode };
54 | 	stack_push_val(stack, val);
55 | }
56 | 
57 | static inline int
58 | stack_any_val(struct stack *stack, struct val val) {
59 | 	void **p = stack->bottom;
60 | 	struct val *cval;
61 | 
62 | 	while (p < stack->top) {
63 | 		cval = (struct val*)p;
64 | 		if (val.type == cval->type && val.ind == cval->ind)
65 | 			return 1;
66 | 		p++;
67 | 	}
68 | 
69 | 	return 0;
70 | }
71 | 
72 | #endif /* BTCS_VALSTACK_H */
73 | 


--------------------------------------------------------------------------------
/compiler.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef COMPILER_H
 3 | #define COMPILER_H
 4 | 
 5 | #include <stdbool.h>
 6 | #include <stdlib.h>
 7 | #include <string.h>
 8 | 
 9 | bool alignment_ok(const void *p, size_t n);
10 | 
11 | #define UNUSED __attribute__((__unused__))
12 | 
13 | /**
14 |  * BUILD_ASSERT - assert a build-time dependency.
15 |  * @cond: the compile-time condition which must be true.
16 |  *
17 |  * Your compile will fail if the condition isn't true, or can't be evaluated
18 |  * by the compiler.  This can only be used within a function.
19 |  *
20 |  * Example:
21 |  *	#include <stddef.h>
22 |  *	...
23 |  *	static char *foo_to_char(struct foo *foo)
24 |  *	{
25 |  *		// This code needs string to be at start of foo.
26 |  *		BUILD_ASSERT(offsetof(struct foo, string) == 0);
27 |  *		return (char *)foo;
28 |  *	}
29 |  */
30 | #define BUILD_ASSERT(cond) \
31 | 	do { (void) sizeof(char [1 - 2*!(cond)]); } while(0)
32 | 
33 | /**
34 |  * BUILD_ASSERT_OR_ZERO - assert a build-time dependency, as an expression.
35 |  * @cond: the compile-time condition which must be true.
36 |  *
37 |  * Your compile will fail if the condition isn't true, or can't be evaluated
38 |  * by the compiler.  This can be used in an expression: its value is "0".
39 |  *
40 |  * Example:
41 |  *	#define foo_to_char(foo)					\
42 |  *		 ((char *)(foo)						\
43 |  *		  + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))
44 |  */
45 | #define BUILD_ASSERT_OR_ZERO(cond) \
46 | 	(sizeof(char [1 - 2*!(cond)]) - 1)
47 | 
48 | #define memclear(mem, size) memset(mem, 0, size)
49 | #define memclear_2(m1, s1, m2, s2) { memclear(m1, s1); memclear(m2, s2); }
50 | #define memclear_3(m1, s1, m2, s2, m3, s3) { memclear(m1, s1); memclear(m2, s2); memclear(m3, s3); }
51 | #define wally_clear memclear
52 | #define wally_clear_2 memclear_2
53 | #define wally_clear_3 memclear_3
54 | 
55 | #endif /* COMPILER_H */
56 | 


--------------------------------------------------------------------------------
/stack.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef BTCS_STACK_H
 3 | #define BTCS_STACK_H
 4 | 
 5 | #include <assert.h>
 6 | #include <string.h>
 7 | #include <stdio.h>
 8 | #include "misc.h"
 9 | 
10 | // Maximum number of values on script interpreter stack
11 | static const int MAX_STACK_SIZE = 1000;
12 | 
13 | // Maximum number of values on script interpreter stack
14 | #define DEFAULT_STACK_SIZE 32
15 | 
16 | struct stack {
17 |   void *_data[DEFAULT_STACK_SIZE];
18 |   void **bottom;
19 |   void **top;
20 |   int capacity;
21 | };
22 | 
23 | int   stack_init(struct stack *);
24 | int   stack_init_size(struct stack *, int size);
25 | void  stack_free(struct stack *);
26 | void  stack_clear(struct stack *);
27 | void* stack_pop(struct stack *);
28 | void  stack_erase(struct stack *, int ind);
29 | void  stack_push(struct stack *, void *val);
30 | 
31 | static inline void *
32 | stack_top(struct stack *stack, int ind) {
33 |   void **p = stack->top + ind;
34 |   assert(p >= stack->bottom);
35 |   assert(p);
36 |   return *p;
37 | }
38 | 
39 | static inline int
40 | stack_size(struct stack *stack) {
41 |   return stack->top - stack->bottom;
42 | }
43 | 
44 | static inline void
45 | stack_swap(struct stack *stack, int ind1, int ind2) {
46 |   void *temp = *(stack->top + ind1);
47 |   *(stack->top + ind1) = *(stack->top + ind2);
48 |   *(stack->top + ind2) = temp;
49 | }
50 | 
51 | #define stack_push_small(T, stack, val) { \
52 |   assert(sizeof(T) <= sizeof(void*)); \
53 |   void *tmp = 0; \
54 |   memcpy(&tmp, val, sizeof(T));                    \
55 |   stack_push(stack, tmp); \
56 | }
57 | 
58 | #define stack_top_small(T, stack, v, ind)     \
59 |   memcpy(v, stack->top + ind, sizeof(T))
60 | 
61 | static inline void
62 | _stack_push_smallt(struct stack *stack, void *p, size_t size) {
63 | #if 0
64 |   u8 *b = (u8*)p;
65 |   printf("pushing small", "");
66 |   for (size_t i = 0; i < size; ++i) {
67 |     printf(" %02x", b[i]);
68 |   }
69 |   printf("\n");
70 | #endif
71 |   assert(size <= sizeof(void*));
72 |   void *tmp = 0;
73 |   memcpy(&tmp, p, size);
74 |   stack_push(stack, tmp);
75 | }
76 | 
77 | #endif /* BTCS_STACK_H */
78 | 


--------------------------------------------------------------------------------
/stack.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "stack.h"
  3 | #include <stdlib.h>
  4 | #include <stdio.h>
  5 | #include <string.h>
  6 | 
  7 | void
  8 | stack_clear(struct stack *stack) {
  9 | 	memset(stack->bottom, 0, stack->capacity);
 10 | 	stack->top = stack->bottom;
 11 | }
 12 | 
 13 | int
 14 | stack_init_size(struct stack *stack, int capacity) {
 15 | 	if (capacity > DEFAULT_STACK_SIZE) {
 16 | 		void *bottom = calloc(capacity, sizeof(void*));
 17 | 		if (!bottom) return 0;
 18 | 		stack->bottom = bottom;
 19 | 		stack->top = bottom;
 20 | 		stack->capacity = capacity;
 21 | 	}
 22 | 	else {
 23 | 		stack->bottom = stack->_data;
 24 | 		stack->top = stack->bottom;
 25 | 		stack->capacity = DEFAULT_STACK_SIZE;
 26 | 	}
 27 | 	stack_clear(stack);
 28 | 	return 1;
 29 | }
 30 | 
 31 | int
 32 | stack_init(struct stack *stack) {
 33 | 	return stack_init_size(stack, DEFAULT_STACK_SIZE);
 34 | }
 35 | 
 36 | void
 37 | stack_free(struct stack *stack) {
 38 | 	if (stack->capacity > DEFAULT_STACK_SIZE)
 39 | 		free(stack->bottom);
 40 | 	stack->bottom = stack->_data;
 41 | }
 42 | 
 43 | 
 44 | int
 45 | stack_expand(struct stack *stack) {
 46 | 	size_t newcap = stack->capacity * 2;
 47 | 	void **bottom = 0;
 48 | 	int size = stack_size(stack);
 49 | 
 50 | #if DEBUG
 51 | 	printf("expanding s(%d) %d -> %d\n", size, stack->capacity, newcap);
 52 | #endif
 53 | 
 54 | 	// XXX: might want to relax this to <= eventually
 55 | 	assert(size == stack->capacity);
 56 | 
 57 | 	if (stack->capacity <= DEFAULT_STACK_SIZE) {
 58 | 		bottom = malloc(newcap * sizeof(void*));
 59 | 		if (!bottom) return 0;
 60 | 		memcpy(bottom, stack->bottom, size * sizeof(void*));
 61 | 	}
 62 | 	else {
 63 | 		bottom = realloc(stack->bottom, newcap * sizeof(void*));
 64 | 		if (!bottom) return 0;
 65 | 	}
 66 | 	stack->capacity = newcap;
 67 | 	stack->bottom	= bottom;
 68 | 	stack->top	= bottom+size;
 69 | 	return 1;
 70 | }
 71 | 
 72 | void
 73 | stack_push(struct stack *stack, void *val) {
 74 | 	#if 0
 75 | 	printf("pushing: %d %p\n", stack_size(stack), val);
 76 | 	#endif
 77 | 
 78 | 	if ((stack_size(stack) + 1) > stack->capacity) {
 79 | 		stack_expand(stack);
 80 | 	}
 81 | 
 82 | 	*stack->top++ = val;
 83 | }
 84 | 
 85 | void
 86 | stack_erase(struct stack *stack, int pos) {
 87 | 	if (stack_size(stack) == 0) return;
 88 | 	size_t len = stack->top - (stack->top + pos);
 89 | 	memcpy(stack->top + pos, stack->top + pos + 1, sizeof(stack->top) * len);
 90 | 	stack->top--;
 91 | }
 92 | 
 93 | void *
 94 | stack_pop(struct stack *stack) {
 95 | 	assert(stack);
 96 | 	assert(stack_size(stack) != 0);
 97 | 	void * v = stack_top(stack, -1);
 98 | 	stack->top--;
 99 | 	return v;
100 | }
101 | 
102 | 


--------------------------------------------------------------------------------
/btcs.1:
--------------------------------------------------------------------------------
  1 | .de dT
  2 | .ds Dt \\$2
  3 | ..
  4 | .dT Time-stamp: "2019-06-13"
  5 | .TH BTCS 1 \*(Dt "btcs" "User Commands"
  6 | .SH NAME
  7 | btcs \- A Bitcoin script compiler, evaluator and decompiler
  8 | .SH SYNOPSIS
  9 | .B btcs
 10 | [\fI\,OPTION\/\fR]... -d <HEXSCRIPT> or [\fI\,EXPRS\/\fR]...
 11 | 
 12 | .SH DESCRIPTION
 13 | btcs accepts bitcoin script over stdin or as arguments
 14 | 
 15 | .SH DECOMPILER OPTIONS
 16 | 
 17 | .TP
 18 | .BR \-d ", " \-\^\-decompile
 19 | Decompile a hex string representing bitcoin script
 20 | 
 21 | .TP
 22 | .BR \-a ", " \-\^\-abbreviate-data
 23 | Abbreviate data pushes when printing script data.
 24 | .br
 25 | For example, hashes would appear as
 26 | .B data(20)
 27 | and
 28 | .B data(32)
 29 | 
 30 | .SH COMPILER OPTIONS
 31 | 
 32 | .TP
 33 | .BR {-,+}l ", " \-\^\-{hide,show}-labels
 34 | Hide or show labels such as "script" and "script_hex".
 35 | .br
 36 | This will default to
 37 | .B hide
 38 | when there is only one printed output
 39 | 
 40 | .TP
 41 | .BR \-s ", " \-\^\-script
 42 | Print the interpreted script
 43 | 
 44 | .TP
 45 | .BR \-s ", " \-\^\-script-hex
 46 | Print the hex form of the script
 47 | 
 48 | .TP
 49 | .BR \-t ", " \-\^\-stack
 50 | Print the stack output
 51 | 
 52 | .TP
 53 | .BR \-th ", " \-\^\-stack-hex
 54 | Print the stack output as hex
 55 | 
 56 | .TP
 57 | .BR \-r ", " \-\^\-result
 58 | Print the evaluation result
 59 | 
 60 | 
 61 | .SH EXPRS
 62 | 
 63 | .SS @<HEX>
 64 | .br
 65 | Prepends a minimal PUSHDATA op with the length of the hex string, and then pushes the hex data
 66 | .br
 67 | eg: @ffabcd
 68 | 
 69 | .SS OPCODE
 70 | .br
 71 | A bitcoin opcode in the form OP_<NAME> or <NAME>
 72 | 
 73 | .SS SCRIPTNUM
 74 | .br
 75 | Literal integers, which get converted to script nums (bitcoin script's number format)
 76 | .br
 77 | eg: 1 2 3 -1 2147483648
 78 | 
 79 | .SS RAW BYTES
 80 | .br
 81 | Literal raw bytes, which may or may not be valid script.
 82 | .br
 83 | eg: pushdata1 0x02 0x0102
 84 | .br
 85 | You could use this for manual or non-minimal pushdata
 86 | 
 87 | .SH EXAMPLES
 88 | 
 89 | .SS
 90 | Basic example
 91 | .br
 92 | $ btcs 1 2 add
 93 | .br
 94 | script      1 2 OP_ADD
 95 | .br
 96 | script_hex  515293
 97 | .br
 98 | stack       3
 99 | .br
100 | stack_hex   03
101 | .br
102 | results     success
103 | 
104 | .SS
105 | Just compile
106 | .br
107 | $ btcs -sh hash160 @b472a266d0bd89c13706a4132ccfb16f7c3b9fcb equalverify
108 | .br
109 | a914b472a266d0bd89c13706a4132ccfb16f7c3b9fcb88
110 | 
111 | 
112 | .SH BUGS
113 | The evaluator isn't consensus-critical. Please test your scripts on testnet before use.
114 | 
115 | .SH AUTHOR
116 | 
117 | William Casarin <jb55@jb55.com>
118 | .br
119 | Support my Bitcoin projects: bc1qthsruffh3qcn69hux2tcq87x95x8rmu4fdu9sm
120 | 


--------------------------------------------------------------------------------
/alloc.c:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | #include <stdlib.h>
  4 | #include <string.h>
  5 | #include <assert.h>
  6 | #include "alloc.h"
  7 | #include "stack.h"
  8 | 
  9 | static struct arenas g_arenas;
 10 | 
 11 | void
 12 | alloc_arenas() {
 13 |   alloc_arena_sizes(0, MAX_STACK_SIZE, MAX_STACK_SIZE * MAX_STACK_SIZE);
 14 | }
 15 | 
 16 | void
 17 | alloc_arena_sizes(struct arenas *arenas, const int nums, const int bytes) {
 18 |   if (!arenas) arenas = &g_arenas;
 19 |   arenas->nums = (struct num*)calloc(nums, sizeof(struct num));
 20 |   assert(arenas->nums);
 21 |   arenas->bytes = (u8*)calloc(bytes, 1);
 22 |   stack_init_size(&arenas->bytes_map, bytes);
 23 |   arenas->bytes_top = arenas->bytes;
 24 |   arenas->num_count = 0;
 25 |   arenas->nbytes = bytes;
 26 | }
 27 | 
 28 | struct num *
 29 | num_pool_get(const u16 ind) {
 30 |   return &g_arenas.nums[ind];
 31 | }
 32 | 
 33 | 
 34 | struct num *
 35 | num_pool_pop() {
 36 |   assert(g_arenas.num_count > 0);
 37 |   return &g_arenas.nums[g_arenas.num_count--];
 38 | }
 39 | 
 40 | 
 41 | struct num *
 42 | num_pool_new(u16 *ind) {
 43 |   *ind = g_arenas.num_count++;
 44 |   struct num *p;
 45 |   p = &g_arenas.nums[*ind];
 46 |   assert(p);
 47 |   assert(p->val == 0 && p->ind == 0);
 48 |   p->ind = *ind;
 49 |   return p;
 50 | }
 51 | 
 52 | unsigned char *byte_pool_new(u32 len, u16 *ind) {
 53 | 	assert((g_arenas.bytes_top - g_arenas.bytes + len) <= g_arenas.nbytes);
 54 | 	u8 *start = g_arenas.bytes_top;
 55 | 	u32 *c = (u32*)g_arenas.bytes_top;
 56 | 	*c++ = len;
 57 | 	u8 *p = (u8*)c;
 58 | 	p += len;
 59 | 	*ind = stack_size(&g_arenas.bytes_map);
 60 | 	stack_push(&g_arenas.bytes_map, (void*)start);
 61 | 	g_arenas.bytes_top = p;
 62 | 	assert(*p == 0);
 63 | 	assert(((g_arenas.bytes_top - g_arenas.bytes) + len) <= g_arenas.nbytes);
 64 | 	return p - len;
 65 | }
 66 | 
 67 | 
 68 | // useful for quick alloc/deallocs
 69 | u8 *
 70 | byte_pool_pop() {
 71 |   u8 *p = (u8*)stack_pop(&g_arenas.bytes_map);
 72 |   u32 *c = (u32*)p;
 73 |   memset(p, 0, *c + sizeof(u32));
 74 |   return p;
 75 | }
 76 | 
 77 | 
 78 | u8 *
 79 | byte_pool_get(int ind, u32 *len) {
 80 |   assert(ind <= stack_size(&g_arenas.bytes_map) - 1);
 81 |   void **vp;
 82 |   u8 *p;
 83 |   u32 *up;
 84 |   vp = g_arenas.bytes_map.bottom + ind;
 85 |   p = (u8*)(*vp);
 86 |   //assert((g_arenas.bytes_top - g_arenas.bytes + *len) <= g_arenas.nbytes);
 87 |   assert(p);
 88 |   up = (u32*)p;
 89 |   *len = *up++;
 90 |   p = (u8*)up;
 91 |   assert((g_arenas.bytes_top - g_arenas.bytes + *len) <= g_arenas.nbytes);
 92 |   return p;
 93 | }
 94 | 
 95 | void
 96 | free_arenas(struct arenas *arenas) {
 97 |   if (!arenas) arenas = &g_arenas;
 98 |   if (!arenas) return;
 99 |   stack_free(&arenas->bytes_map);
100 |   free(arenas->bytes);
101 |   free(arenas->nums);
102 | }
103 | 
104 | 


--------------------------------------------------------------------------------
/test/tests.csv:
--------------------------------------------------------------------------------
 1 | description,args,input,expected output
 2 | test_simple,,OP_1									,script      1 script_hex  51 stack       1 stack_hex   01 results     success
 3 | test_nip,,OP_1 OP_2 OP_NIP							,script      1 2 OP_NIP script_hex  515277 stack       2 stack_hex   02 results     success
 4 | test_2dup_not_enough_input,,OP_1 OP_2DUP			,script      1 OP_2DUP script_hex  516e stack       1 stack_hex   01 results     error:2:INVALID_STACK_OPERATION:2DUP
 5 | negative_integer,,-2								,script      -2 script_hex  0182 stack       0x82 stack_hex   82 results     success
 6 | add_negative_two,,-2 -2 OP_ADD						,script      -2 -2 OP_ADD script_hex  0182018293 stack       -4 stack_hex   84 results     success
 7 | big_int_serializes_ok,,2147483647 2147483647 OP_ADD	,script      2147483647 2147483647 OP_ADD script_hex  04ffffff7f04ffffff7f93 stack       @feffffff00 stack_hex   feffffff00 results     success
 8 | test_small_int,,127									,script      127 script_hex  017f stack       0x7f stack_hex   7f results     success
 9 | test_OP_1ADD,,16 OP_1ADD							,script      16 OP_1ADD script_hex  608b stack       17 stack_hex   11 results     success
10 | test_OP_1SUB,,16 OP_1SUB							,script      16 OP_1SUB script_hex  608c stack       15 stack_hex   0f results     success
11 | test_OP_NEGATE,,2 OP_NEGATE							,script      2 OP_NEGATE script_hex  528f stack       -2 stack_hex   82 results     success
12 | test_OP_NEGATE_negative,,-2 OP_NEGATE				,script      -2 OP_NEGATE script_hex  01828f stack       2 stack_hex   02 results     success
13 | test_OP_ABS,,2 OP_ABS								,script      2 OP_ABS script_hex  5290 stack       2 stack_hex   02 results     success
14 | test_OP_ABS_negative,,-2 OP_ABS						,script      -2 OP_ABS script_hex  018290 stack       2 stack_hex   02 results     success
15 | sub_negative_two,,-2 -12 OP_SUB						,script      -2 -12 OP_SUB script_hex  0182018c94 stack       10 stack_hex   0a results     success
16 | test_OP_DROP,,-1 OP_DROP							,script      -1 OP_DROP script_hex  4f75 stack        stack_hex    results     success
17 | test_OP_NOT_0,,0 OP_NOT								,script      0 OP_NOT script_hex  0091 stack       1 stack_hex   01 results     success
18 | test_OP_NOT_1,,1 OP_NOT								,script      1 OP_NOT script_hex  5191 stack       0 stack_hex   00 results     success
19 | test_OP_NOT_2,,2 OP_NOT								,script      2 OP_NOT script_hex  5291 stack       0 stack_hex   00 results     success
20 | test_OP_0NOTEQUAL0,,0 OP_0NOTEQUAL					,script      0 OP_0NOTEQUAL script_hex  0092 stack       0 stack_hex   00 results     success
21 | test_OP_0NOTEQUAL2,,2 OP_0NOTEQUAL					,script      2 OP_0NOTEQUAL script_hex  5292 stack       1 stack_hex   01 results     success
22 | test_ADD_SUB,,111 1 OP_ADD 12 OP_SUB				,script      111 1 OP_ADD 12 OP_SUB script_hex  016f51935c94 stack       100 stack_hex   64 results     success
23 | test_BOOLAND,,1 1 OP_BOOLAND						,script      1 1 OP_BOOLAND script_hex  51519a stack       1 stack_hex   01 results     success
24 | test_BOOLAND,,0 0 OP_BOOLAND						,script      0 0 OP_BOOLAND script_hex  00009a stack       0 stack_hex   00 results     success
25 | 


--------------------------------------------------------------------------------
/util.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "util.h"
  3 | #include <errno.h>
  4 | #include <assert.h>
  5 | 
  6 | static bool char_to_hex(unsigned char *val, char c)
  7 | {
  8 | 	if (c >= '0' && c <= '9') {
  9 | 		*val = c - '0';
 10 | 		return true;
 11 | 	}
 12 |  	if (c >= 'a' && c <= 'f') {
 13 | 		*val = c - 'a' + 10;
 14 | 		return true;
 15 | 	}
 16 |  	if (c >= 'A' && c <= 'F') {
 17 | 		*val = c - 'A' + 10;
 18 | 		return true;
 19 | 	}
 20 | 	return false;
 21 | }
 22 | 
 23 | bool hex_decode(const char *str, size_t *slen, void *buf, size_t bufsize)
 24 | {
 25 | 	unsigned char v1, v2;
 26 | 	unsigned char *p = buf;
 27 | 	int len = 0;
 28 | 
 29 | 	while (*slen > 1) {
 30 | 		if (!bufsize || !char_to_hex(&v1, str[0]) || !char_to_hex(&v2, str[1])) {
 31 | 			*slen = len;
 32 | 			return false;
 33 | 		}
 34 | 		*(p++) = (v1 << 4) | v2;
 35 | 		str += 2;
 36 | 		*slen -= 2;
 37 | 		bufsize--;
 38 | 		len += 2;
 39 | 	}
 40 | 	*slen = len;
 41 | 	return *slen == 0 && bufsize == 0;
 42 | }
 43 | 
 44 | 
 45 | int read_fd(FILE *fd, unsigned char *buf, size_t buflen, size_t *written)
 46 | {
 47 | 	unsigned char *p = buf;
 48 | 	int len = 0;
 49 | 	*written = 0;
 50 | 
 51 | 	do {
 52 | 		len = fread(p, 1, 4096, fd);
 53 | 		*written += len;
 54 | 		p += len;
 55 | 		if (p > buf + buflen)
 56 | 			return 0;
 57 | 	} while (len == 4096);
 58 | 
 59 | 	return 1;
 60 | }
 61 | 
 62 | 	
 63 | 
 64 | // if typedef doesn't exist (msvc, blah)
 65 | ssize_t getline(char **lineptr, size_t *n, FILE *stream) {
 66 |     size_t pos;
 67 |     int c;
 68 | 
 69 |     if (lineptr == NULL || stream == NULL || n == NULL) {
 70 |         errno = EINVAL;
 71 |         return -1;
 72 |     }
 73 | 
 74 |     c = getc(stream);
 75 |     if (c == EOF) {
 76 |         return -1;
 77 |     }
 78 | 
 79 |     if (*lineptr == NULL) {
 80 |         *lineptr = malloc(128);
 81 |         if (*lineptr == NULL) {
 82 |             return -1;
 83 |         }
 84 |         *n = 128;
 85 |     }
 86 | 
 87 |     pos = 0;
 88 |     while(c != EOF) {
 89 |         if (pos + 1 >= *n) {
 90 |             size_t new_size = *n + (*n >> 2);
 91 |             if (new_size < 128) {
 92 |                 new_size = 128;
 93 |             }
 94 |             char *new_ptr = realloc(*lineptr, new_size);
 95 |             if (new_ptr == NULL) {
 96 |                 return -1;
 97 |             }
 98 |             *n = new_size;
 99 |             *lineptr = new_ptr;
100 |         }
101 | 
102 |         ((unsigned char *)(*lineptr))[pos ++] = c;
103 |         if (c == '\n') {
104 |             break;
105 |         }
106 |         c = getc(stream);
107 |     }
108 | 
109 |     (*lineptr)[pos] = '\0';
110 |     return pos;
111 | }
112 | 
113 | int read_arg_or_stdin(const char *arg, unsigned char *buf, size_t buflen,
114 | 		      size_t *written)
115 | {
116 | 	if (arg != NULL) {
117 | 		unsigned char *p = buf;
118 | 		bool done = false;
119 | 		for (size_t i = 0; i < buflen; i++) {
120 | 			*p = arg[i];
121 | 			if (*p == 0 ) {
122 | 				done = true;
123 | 				break;
124 | 			}
125 | 			p++;
126 | 		}
127 | 
128 | 		*written = p - buf;
129 | 
130 | 		return done;
131 | 	}
132 | 	else {
133 | 		int ok = read_fd(stdin, buf, buflen, written);
134 | 		if (!ok)
135 | 			return ok;
136 | 		if (*written == 0)
137 | 			return 0;
138 | 		(*written)--;
139 | 		buf[*written] = 0;
140 | 		return ok;
141 | 	}
142 | }
143 | 
144 | 


--------------------------------------------------------------------------------
/val.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <assert.h>
  3 | #include "op.h"
  4 | #include "val.h"
  5 | #include "alloc.h"
  6 | #include "script_num.h"
  7 | 
  8 | static const char intbytes[] = {
  9 | 	OP_1NEGATE,
 10 | 	OP_0,
 11 | 	OP_1, OP_2, OP_3, OP_4, OP_5,
 12 | 	OP_6, OP_7, OP_8, OP_9, OP_10,
 13 | 	OP_11, OP_12, OP_13, OP_14, OP_15,
 14 | 	OP_16
 15 | };
 16 | 
 17 | struct val
 18 | val_from_int(s64 intval) {
 19 | 	struct val val;
 20 | 	struct num *sn;
 21 | 	u16 ind;
 22 | 	sn = num_pool_new(&ind);
 23 | 	val.type = VT_SCRIPTNUM;
 24 | 	val.ind = ind;
 25 | 	sn->ind = ind;
 26 | 	sn->val = intval;
 27 | 	return val;
 28 | }
 29 | 
 30 | // TODO maybe replace this with serialize
 31 | void val_bytes(struct val val, u32 *len, u8 *buf, int bufsize) {
 32 | 	if (val.type == VT_DATA)
 33 | 		val.type = VT_RAW;
 34 | 	val_serialize(val, len, buf, bufsize);
 35 | }
 36 | 
 37 | void val_serialize(struct val val, u32 *len, u8 *buf, int bufsize) {
 38 | 	struct num *sn;
 39 | 	int n;
 40 | 	u16 valsize;
 41 | 	switch (val.type) {
 42 | 	case VT_SCRIPTNUM:
 43 | 		sn = num_pool_get(val.ind);
 44 | 		assert(sn);
 45 | 
 46 | 		/// TODO: if serialize_minimal
 47 | 		sn_serialize(sn, buf, bufsize, &valsize);
 48 | 		assert(valsize <= 0xFF);
 49 | 		*len = valsize;
 50 | 		return;
 51 | 	case VT_OP:
 52 | 		*len = 1;
 53 | 		*buf = val.ind & 0xFF;
 54 | 		return;
 55 | 	case VT_DATA:
 56 | 	case VT_RAW: {
 57 | 		u8 *p;
 58 | 		p = byte_pool_get(val.ind, len);
 59 | 		memcpy(buf, p, *len);
 60 | 		return;
 61 | 	}
 62 | 	case VT_SMALLINT:
 63 | 		assert(0);
 64 | 		*len = 1;
 65 | 		n = val.ind;
 66 | 		if (n >= -1 && n <= 16) {
 67 | 			val.type = VT_SMALLINT;
 68 | 			assert(bufsize >= 1);
 69 | 			*buf = intbytes[n+1];
 70 | 		}
 71 | 		else {
 72 | 			assert(!"non-small VT_SMALLINT");
 73 | 		}
 74 | 		return;
 75 | 	}
 76 | 
 77 | 	assert(!"val_serialize missing implementation");
 78 | }
 79 | 
 80 | 
 81 | int val_eq(struct val a, struct val b) {
 82 | 	u32 alen = 0, blen = 0;
 83 | 	int eq = 0;
 84 | 
 85 | 	static const int tmpsize = 4096;
 86 | 	static u8 tmpa[4096];
 87 | 	static u8 tmpb[4096];
 88 | 
 89 | 	// TODO: do I need to serialize to compare?
 90 | 	/* abytes = val_serialize(a, &alen, require_minimal); */
 91 | 	/* bbytes = val_serialize(b, &blen, require_minimal); */
 92 | 	val_serialize(a, &alen, tmpa, tmpsize);
 93 | 	val_serialize(b, &blen, tmpb, tmpsize);
 94 | 	// TODO: what if they're semantically equivalent? or does that matter
 95 | 	// (eg. minimal vs not miniminal)?
 96 | 
 97 | 	if (alen != blen)
 98 | 		return 0;
 99 | 
100 | 	eq = memcmp(tmpa, tmpb, alen) == 0;
101 | 
102 | 	return eq;
103 | }
104 | 
105 | struct val val_cat(struct val a, struct val b)
106 | {
107 | 	struct val c = { .type = VT_RAW };
108 | 	unsigned char *dst, *a_src, *b_src;
109 | 	u16 ind;
110 | 	u32 a_len, b_len;
111 | 	a_src = byte_pool_get(a.ind, &a_len);
112 | 	b_src = byte_pool_get(b.ind, &b_len);
113 | 	dst = byte_pool_new(a_len + b_len, &ind);
114 | 	memcpy(dst, a_src, a_len);
115 | 	memcpy(dst + a_len, b_src, b_len);
116 | 	c.ind = ind;
117 | 	return c;
118 | }
119 | 
120 | struct val
121 | val_copy(struct val a) {
122 | 	u32 len;
123 | 	u16 newind;
124 | 	u8 *src, *dst;
125 | 	struct num *nsrc, *ndst;
126 | 
127 | 	switch (a.type) {
128 | 	case VT_SMALLINT:
129 | 		return a;
130 | 	case VT_RAW:
131 | 	case VT_DATA:
132 | 		src = byte_pool_get(a.ind, &len);
133 | 		dst = byte_pool_new(len, &newind);
134 | 		memcpy(dst, src, len);
135 | 		a.ind = newind;
136 | 		return a;
137 | 	case VT_SCRIPTNUM:
138 | 		nsrc = num_pool_get(a.ind);
139 | 		ndst = num_pool_new(&newind);
140 | 		ndst->val = nsrc->val;
141 | 		return sn_to_val(ndst);
142 | 	default:
143 | 		assert(!"unhandle val_copy enum");
144 | 	}
145 | }
146 | 
147 | u32
148 | val_size(struct val val) {
149 | 	u32 len;
150 | 
151 | 	switch (val.type) {
152 | 	case VT_DATA: {
153 | 		byte_pool_get(val.ind, &len);
154 | 		return len;
155 | 	}
156 | 	default:
157 | 		return 1;
158 | 	}
159 | }
160 | 
161 | /* struct val */
162 | /* val_int(s64 n) { */
163 | /*	 struct val val; */
164 | /* } */
165 | 


--------------------------------------------------------------------------------
/mph-opcodes:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | # Easy Perfect Minimal Hashing
  3 | # By Steve Hanov. Released to the public domain.
  4 | #
  5 | # Based on:
  6 | # Edward A. Fox, Lenwood S. Heath, Qi Fan Chen and Amjad M. Daoud,
  7 | # "Practical minimal perfect hash functions for large databases", CACM, 35(1):105-121
  8 | # also a good reference:
  9 | # Compress, Hash, and Displace algorithm by Djamal Belazzougui,
 10 | # Fabiano C. Botelho, and Martin Dietzfelbinger
 11 | import sys
 12 | 
 13 | DICTIONARY = sys.argv[1]
 14 | 
 15 | # Calculates a distinct hash function for a given string. Each value of the
 16 | # integer d results in a different hash value.
 17 | def hash( d, str ):
 18 |     if d == 0: d = 0x01000193
 19 | 
 20 |     # Use the FNV algorithm from http://isthe.com/chongo/tech/comp/fnv/
 21 |     for c in str:
 22 |         d = ( (d * 0x01000193) ^ ord(c) ) & 0xffffffff;
 23 | 
 24 |     return d
 25 | 
 26 | # Computes a minimal perfect hash table using the given python dictionary. It
 27 | # returns a tuple (G, V). G and V are both arrays. G contains the intermediate
 28 | # table of values needed to compute the index of the value in V. V contains the
 29 | # values of the dictionary.
 30 | def CreateMinimalPerfectHash( dict ):
 31 |     size = len(dict)
 32 | 
 33 |     # Step 1: Place all of the keys into buckets
 34 |     buckets = [ [] for i in range(size) ]
 35 |     G = [0] * size
 36 |     values = [None] * size
 37 | 
 38 |     for key in dict.keys():
 39 |         buckets[hash(0, key) % size].append( key )
 40 | 
 41 |     # Step 2: Sort the buckets and process the ones with the most items first.
 42 |     buckets.sort( key=len, reverse=True )
 43 |     for b in range( size ):
 44 |         bucket = buckets[b]
 45 |         if len(bucket) <= 1: break
 46 | 
 47 |         d = 1
 48 |         item = 0
 49 |         slots = []
 50 | 
 51 |         # Repeatedly try different values of d until we find a hash function
 52 |         # that places all items in the bucket into free slots
 53 |         while item < len(bucket):
 54 |             slot = hash( d, bucket[item] ) % size
 55 |             if values[slot] != None or slot in slots:
 56 |                 d += 1
 57 |                 item = 0
 58 |                 slots = []
 59 |             else:
 60 |                 slots.append( slot )
 61 |                 item += 1
 62 | 
 63 |         G[hash(0, bucket[0]) % size] = d
 64 |         for i in range(len(bucket)):
 65 |             values[slots[i]] = dict[bucket[i]]
 66 | 
 67 |     # Only buckets with 1 item remain. Process them more quickly by directly
 68 |     # placing them into a free slot. Use a negative value of d to indicate
 69 |     # this.
 70 |     freelist = []
 71 |     for i in range(size):
 72 |         if values[i] == None: freelist.append( i )
 73 | 
 74 |     for b in range( b, size ):
 75 |         bucket = buckets[b]
 76 |         if len(bucket) == 0: break
 77 |         slot = freelist.pop()
 78 |         # We subtract one to ensure it's negative even if the zeroeth slot was
 79 |         # used.
 80 |         G[hash(0, bucket[0]) % size] = -slot-1
 81 |         values[slot] = dict[bucket[0]]
 82 | 
 83 |     return (G, values)
 84 | 
 85 | # Look up a value in the hash table, defined by G and V.
 86 | def PerfectHashLookup( G, V, key ):
 87 |     d = G[hash(0,key) % len(G)]
 88 |     if d < 0: return V[-d-1]
 89 |     return V[hash(d, key) % len(V)]
 90 | 
 91 | dict = {}
 92 | line = 1
 93 | keys = map(lambda x: x.strip(), open(DICTIONARY, "rt").readlines())
 94 | for key in keys:
 95 |     dict[key] = line
 96 |     line += 1
 97 | 
 98 | (G, V) = CreateMinimalPerfectHash( dict )
 99 | 
100 | Gstrs = ",".join(map(str, G))
101 | Vstrs = ",".join(map(str, V))
102 | 
103 | header = open('oplookup.h', 'w')
104 | 
105 | 
106 | 
107 | header.write("/* THIS IS GENERATED FROM mph-opcodes DO NOT EDIT */\n\n")
108 | header.write("#ifndef BCS_OPLOOKUP_H\n")
109 | header.write("#define BCS_OPLOOKUP_H\n\n")
110 | 
111 | header.write("#include \"misc.h\"\n")
112 | header.write("extern const int opcodes_g[{}];\n".format(len(G)))
113 | header.write("extern const int opcodes_v[{}];\n".format(len(V)))
114 | header.write("\n#endif /* BCS_OPLOOKUP_H */\n")
115 | header.close()
116 | 
117 | cfile = open('oplookup.c', 'w')
118 | 
119 | cfile.write("/* THIS IS GENERATED FROM mph-opcodes DO NOT EDIT */\n\n")
120 | cfile.write("#include \"oplookup.h\"\n".format(Gstrs))
121 | cfile.write("const int opcodes_g[{}] = {{ {} }};\n".format(len(G), Gstrs))
122 | cfile.write("const int opcodes_v[{}] = {{ {} }};\n".format(len(V), Vstrs))
123 | cfile.close()
124 | 


--------------------------------------------------------------------------------
/ripemd160.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef CCAN_CRYPTO_RIPEMD160_H
  3 | #define CCAN_CRYPTO_RIPEMD160_H
  4 | /* BSD-MIT - see LICENSE file for details */
  5 | #include <stdint.h>
  6 | #include <stdlib.h>
  7 | 
  8 | /* Uncomment this to use openssl's RIPEMD160 routines (and link with -lcrypto) */
  9 | /*#define CCAN_CRYPTO_RIPEMD160_USE_OPENSSL 1*/
 10 | 
 11 | #ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL
 12 | #include <openssl/ripemd.h>
 13 | #endif
 14 | 
 15 | /**
 16 |  * struct ripemd160 - structure representing a completed RIPEMD160.
 17 |  * @u.u8: an unsigned char array.
 18 |  * @u.u32: a 32-bit integer array.
 19 |  *
 20 |  * Other fields may be added to the union in future.
 21 |  */
 22 | struct ripemd160 {
 23 | 	union {
 24 | 		/* Array of chars */
 25 | 		unsigned char u8[20];
 26 | 		/* Array of uint32_t */
 27 | 		uint32_t u32[5];
 28 | 	} u;
 29 | };
 30 | 
 31 | /**
 32 |  * ripemd160 - return ripemd160 of an object.
 33 |  * @ripemd160: the ripemd160 to fill in
 34 |  * @p: pointer to memory,
 35 |  * @size: the number of bytes pointed to by @p
 36 |  *
 37 |  * The bytes pointed to by @p is RIPEMD160 hashed into @ripemd160.  This is
 38 |  * equivalent to ripemd160_init(), ripemd160_update() then ripemd160_done().
 39 |  */
 40 | void ripemd160(struct ripemd160 *ripemd, const void *p, size_t size);
 41 | 
 42 | /**
 43 |  * struct ripemd160_ctx - structure to store running context for ripemd160
 44 |  */
 45 | struct ripemd160_ctx {
 46 | #ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL
 47 | 	RIPEMD160_CTX c;
 48 | #else
 49 | 	uint32_t s[5];
 50 | 	uint64_t bytes;
 51 | 	union {
 52 | 		uint32_t u32[16];
 53 | 		unsigned char u8[64];
 54 | 	} buf;
 55 | #endif
 56 | };
 57 | 
 58 | /**
 59 |  * ripemd160_init - initialize an RIPEMD160 context.
 60 |  * @ctx: the ripemd160_ctx to initialize
 61 |  *
 62 |  * This must be called before ripemd160_update or ripemd160_done, or
 63 |  * alternately you can assign RIPEMD160_INIT.
 64 |  *
 65 |  * If it was already initialized, this forgets anything which was
 66 |  * hashed before.
 67 |  *
 68 |  * Example:
 69 |  * static void hash_all(const char **arr, struct ripemd160 *hash)
 70 |  * {
 71 |  *	size_t i;
 72 |  *	struct ripemd160_ctx ctx;
 73 |  *
 74 |  *	ripemd160_init(&ctx);
 75 |  *	for (i = 0; arr[i]; i++)
 76 |  *		ripemd160_update(&ctx, arr[i], strlen(arr[i]));
 77 |  *	ripemd160_done(&ctx, hash);
 78 |  * }
 79 |  */
 80 | void ripemd160_init(struct ripemd160_ctx *ctx);
 81 | 
 82 | /**
 83 |  * RIPEMD160_INIT - initializer for an RIPEMD160 context.
 84 |  *
 85 |  * This can be used to staticly initialize an RIPEMD160 context (instead
 86 |  * of ripemd160_init()).
 87 |  *
 88 |  * Example:
 89 |  * static void hash_all(const char **arr, struct ripemd160 *hash)
 90 |  * {
 91 |  *	size_t i;
 92 |  *	struct ripemd160_ctx ctx = RIPEMD160_INIT;
 93 |  *
 94 |  *	for (i = 0; arr[i]; i++)
 95 |  *		ripemd160_update(&ctx, arr[i], strlen(arr[i]));
 96 |  *	ripemd160_done(&ctx, hash);
 97 |  * }
 98 |  */
 99 | #ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL
100 | #define RIPEMD160_INIT							\
101 | 	{ { 0x67452301ul, 0xEFCDAB89ul, 0x98BADCFEul, 0x10325476ul,	\
102 | 	    0xC3D2E1F0ul,						\
103 | 	    0x0, 0x0,							\
104 | 	    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },		\
105 | 	    0 } }
106 | #else
107 | #define RIPEMD160_INIT							\
108 | 	{ { 0x67452301ul, 0xEFCDAB89ul, 0x98BADCFEul, 0x10325476ul,	\
109 | 	    0xC3D2E1F0ul }, 0, {{ 0 }} }
110 | #endif
111 | 
112 | /**
113 |  * ripemd160_update - include some memory in the hash.
114 |  * @ctx: the ripemd160_ctx to use
115 |  * @p: pointer to memory,
116 |  * @size: the number of bytes pointed to by @p
117 |  *
118 |  * You can call this multiple times to hash more data, before calling
119 |  * ripemd160_done().
120 |  */
121 | void ripemd160_update(struct ripemd160_ctx *ctx, const void *p, size_t size);
122 | 
123 | /**
124 |  * ripemd160_done - finish RIPEMD160 and return the hash
125 |  * @ctx: the ripemd160_ctx to complete
126 |  * @res: the hash to return.
127 |  *
128 |  * Note that @ctx is *destroyed* by this, and must be reinitialized.
129 |  * To avoid that, pass a copy instead.
130 |  */
131 | void ripemd160_done(struct ripemd160_ctx *ripemd160, struct ripemd160 *res);
132 | 
133 | /* Add various types to an RIPEMD160 hash */
134 | void ripemd160_u8(struct ripemd160_ctx *ctx, uint8_t v);
135 | void ripemd160_u16(struct ripemd160_ctx *ctx, uint16_t v);
136 | void ripemd160_u32(struct ripemd160_ctx *ctx, uint32_t v);
137 | void ripemd160_u64(struct ripemd160_ctx *ctx, uint64_t v);
138 | 
139 | /* Add as little-endian */
140 | void ripemd160_le16(struct ripemd160_ctx *ctx, uint16_t v);
141 | void ripemd160_le32(struct ripemd160_ctx *ctx, uint32_t v);
142 | void ripemd160_le64(struct ripemd160_ctx *ctx, uint64_t v);
143 | 
144 | /* Add as big-endian */
145 | void ripemd160_be16(struct ripemd160_ctx *ctx, uint16_t v);
146 | void ripemd160_be32(struct ripemd160_ctx *ctx, uint32_t v);
147 | void ripemd160_be64(struct ripemd160_ctx *ctx, uint64_t v);
148 | #endif /* CCAN_CRYPTO_RIPEMD160_H */
149 | 


--------------------------------------------------------------------------------
/sha256.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef CCAN_CRYPTO_SHA256_H
  3 | #define CCAN_CRYPTO_SHA256_H
  4 | 
  5 | 
  6 | /** Output length for `wally_sha256` */
  7 | #define SHA256_LEN 32
  8 | 
  9 | 
 10 | /* BSD-MIT - see LICENSE file for details */
 11 | /* #include "config.h" */
 12 | #include <stdint.h>
 13 | #include <stdlib.h>
 14 | 
 15 | /* Uncomment this to use openssl's SHA256 routines (and link with -lcrypto) */
 16 | /*#define CCAN_CRYPTO_SHA256_USE_OPENSSL 1*/
 17 | 
 18 | #ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
 19 | #include <openssl/sha.h>
 20 | #endif
 21 | 
 22 | /**
 23 |  * struct sha256 - structure representing a completed SHA256.
 24 |  * @u.u8: an unsigned char array.
 25 |  * @u.u32: a 32-bit integer array.
 26 |  *
 27 |  * Other fields may be added to the union in future.
 28 |  */
 29 | struct sha256 {
 30 | 	union {
 31 | 		uint32_t u32[8];
 32 | 		unsigned char u8[32];
 33 | 	} u;
 34 | };
 35 | 
 36 | /**
 37 |  * sha256 - return sha256 of an object.
 38 |  * @sha256: the sha256 to fill in
 39 |  * @p: pointer to memory,
 40 |  * @size: the number of bytes pointed to by @p
 41 |  *
 42 |  * The bytes pointed to by @p is SHA256 hashed into @sha256.  This is
 43 |  * equivalent to sha256_init(), sha256_update() then sha256_done().
 44 |  */
 45 | void sha256(struct sha256 *sha, const void *p, size_t size);
 46 | 
 47 | /**
 48 |  * struct sha256_ctx - structure to store running context for sha256
 49 |  */
 50 | struct sha256_ctx {
 51 | #ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
 52 | 	SHA256_CTX c;
 53 | #else
 54 | 	uint32_t s[8];
 55 | 	union {
 56 | 		uint32_t u32[16];
 57 | 		unsigned char u8[64];
 58 | 	} buf;
 59 | 	size_t bytes;
 60 | #endif
 61 | };
 62 | 
 63 | /**
 64 |  * sha256_init - initialize an SHA256 context.
 65 |  * @ctx: the sha256_ctx to initialize
 66 |  *
 67 |  * This must be called before sha256_update or sha256_done, or
 68 |  * alternately you can assign SHA256_INIT.
 69 |  *
 70 |  * If it was already initialized, this forgets anything which was
 71 |  * hashed before.
 72 |  *
 73 |  * Example:
 74 |  * static void hash_all(const char **arr, struct sha256 *hash)
 75 |  * {
 76 |  *	size_t i;
 77 |  *	struct sha256_ctx ctx;
 78 |  *
 79 |  *	sha256_init(&ctx);
 80 |  *	for (i = 0; arr[i]; i++)
 81 |  *		sha256_update(&ctx, arr[i], strlen(arr[i]));
 82 |  *	sha256_done(&ctx, hash);
 83 |  * }
 84 |  */
 85 | void sha256_init(struct sha256_ctx *ctx);
 86 | 
 87 | /**
 88 |  * SHA256_INIT - initializer for an SHA256 context.
 89 |  *
 90 |  * This can be used to statically initialize an SHA256 context (instead
 91 |  * of sha256_init()).
 92 |  *
 93 |  * Example:
 94 |  * static void hash_all(const char **arr, struct sha256 *hash)
 95 |  * {
 96 |  *	size_t i;
 97 |  *	struct sha256_ctx ctx = SHA256_INIT;
 98 |  *
 99 |  *	for (i = 0; arr[i]; i++)
100 |  *		sha256_update(&ctx, arr[i], strlen(arr[i]));
101 |  *	sha256_done(&ctx, hash);
102 |  * }
103 |  */
104 | #ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
105 | #define SHA256_INIT							\
106 | 	{ { { 0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul,	\
107 | 	      0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul }, \
108 | 		0x0, 0x0,						\
109 | 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },	\
110 | 			0x0, 0x20 } }
111 | #else
112 | #define SHA256_INIT							\
113 | 	{ { 0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul,	\
114 | 	    0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul },	\
115 | 	  { { 0 } }, 0 }
116 | #endif
117 | 
118 | /**
119 |  * sha256_update - include some memory in the hash.
120 |  * @ctx: the sha256_ctx to use
121 |  * @p: pointer to memory,
122 |  * @size: the number of bytes pointed to by @p
123 |  *
124 |  * You can call this multiple times to hash more data, before calling
125 |  * sha256_done().
126 |  */
127 | void sha256_update(struct sha256_ctx *ctx, const void *p, size_t size);
128 | 
129 | /**
130 |  * sha256_done - finish SHA256 and return the hash
131 |  * @ctx: the sha256_ctx to complete
132 |  * @res: the hash to return.
133 |  *
134 |  * Note that @ctx is *destroyed* by this, and must be reinitialized.
135 |  * To avoid that, pass a copy instead.
136 |  */
137 | void sha256_done(struct sha256_ctx *sha256, struct sha256 *res);
138 | 
139 | /* Add various types to an SHA256 hash */
140 | void sha256_u8(struct sha256_ctx *ctx, uint8_t v);
141 | void sha256_u16(struct sha256_ctx *ctx, uint16_t v);
142 | void sha256_u32(struct sha256_ctx *ctx, uint32_t v);
143 | void sha256_u64(struct sha256_ctx *ctx, uint64_t v);
144 | 
145 | /* Add as little-endian */
146 | void sha256_le16(struct sha256_ctx *ctx, uint16_t v);
147 | void sha256_le32(struct sha256_ctx *ctx, uint32_t v);
148 | void sha256_le64(struct sha256_ctx *ctx, uint64_t v);
149 | 
150 | /* Add as big-endian */
151 | void sha256_be16(struct sha256_ctx *ctx, uint16_t v);
152 | void sha256_be32(struct sha256_ctx *ctx, uint32_t v);
153 | void sha256_be64(struct sha256_ctx *ctx, uint64_t v);
154 | 
155 | int sha256d(const unsigned char *bytes, size_t bytes_len,
156 | 	    unsigned char *bytes_out, size_t len);
157 | 
158 | #endif /* CCAN_CRYPTO_SHA256_H */
159 | 


--------------------------------------------------------------------------------
/script_num.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "script_num.h"
  3 | #include "alloc.h"
  4 | #include "val.h"
  5 | #include <limits.h>
  6 | #include <inttypes.h>
  7 | 
  8 | /**
  9 |  * Numeric opcodes (OP_1ADD, etc) are restricted to operating on 4-byte
 10 |  * integers. The semantics are subtle, though: operands must be in the range
 11 |  * [-2^31 +1...2^31 -1], but results may overflow (and are valid as long as they
 12 |  * are not used in a subsequent numeric operation). struct num enforces those
 13 |  * semantics by storing results as an int64 and allowing out-of-range values to
 14 |  * be returned, but throwing an exception if arithmetic is done or the result is
 15 |  * interpreted as an integer.
 16 |  */
 17 | 
 18 | 
 19 | void
 20 | sn_from_int(s64 n, struct num *sn) {
 21 |   sn->ind = -1;
 22 |   sn->val = n;
 23 | }
 24 | 
 25 | 
 26 | /* enum sn_result */
 27 | /* sn_to_int(struct num *sn, int *res) { */
 28 | /*   if (sn_overflowed(sn)) { */
 29 | /*     return SN_ERR_OVERFLOWED_INT; */
 30 | /*   } */
 31 | /* } */
 32 | 
 33 | 
 34 | void sn_serialize(struct num *sn, u8 *buf, int bufsize, u16 *len) {
 35 |   u8 *p = buf;
 36 | 
 37 |   if(sn->val == 0) {
 38 |     *len = 0;
 39 |     return;
 40 |   }
 41 | 
 42 |   const int neg = sn->val < 0;
 43 |   u64 absvalue = neg ? -(sn->val) : sn->val;
 44 | 
 45 |   while(absvalue) {
 46 |     *(p++) = absvalue & 0xff;
 47 |     assert((p - buf) <= bufsize);
 48 |     absvalue >>= 8;
 49 |   }
 50 | 
 51 |   //    - If the most significant byte is >= 0x80 and the value is positive, push a
 52 |   //    new zero-byte to make the significant byte < 0x80 again.
 53 | 
 54 |   //    - If the most significant byte is >= 0x80 and the value is negative, push a
 55 |   //    new 0x80 byte that will be popped off when converting to an integral.
 56 | 
 57 |   //    - If the most significant byte is < 0x80 and the value is negative, add
 58 |   //    0x80 to it, since it will be subtracted and interpreted as a negative when
 59 |   //    converting to an integral.
 60 | 
 61 |   if (*(p - 1) & 0x80)
 62 |     *(p++) = neg ? 0x80 : 0;
 63 |   else if (neg)
 64 |     *(p - 1) |= 0x80;
 65 | 
 66 |   *len = p - buf;
 67 | }
 68 | 
 69 | static inline int
 70 | int_overflowed(s64 val) {
 71 |   return val < INT_MIN || val > INT_MAX;
 72 | }
 73 | 
 74 | 
 75 | int
 76 | sn_overflowed(struct num *num) {
 77 |   return int_overflowed(num->val);
 78 | }
 79 | 
 80 | 
 81 | s64
 82 | int_from_data(u8 *data, u16 size) {
 83 |   s64 result = 0;
 84 | 
 85 |   if (size == 0)
 86 |     return 0;
 87 | 
 88 |   for (size_t i = 0; i != size; ++i)
 89 |     result |= (s64)((data[i]) << 8*i);
 90 | 
 91 |   // If the input vector's most significant byte is 0x80, remove it from
 92 |   // the result's msb and return a negative.
 93 |   if (data[size-1] & 0x80) {
 94 |     return -((s64)(result & ~(0x80ULL << (8 * (size - 1)))));
 95 |   }
 96 | 
 97 |   return result;
 98 | }
 99 | 
100 | 
101 | enum sn_result
102 | sn_from_data(u8 *data, u16 size, struct num **num) {
103 |   u16 ind;
104 |   s64 i;
105 |   if (size > 4)
106 |     return SN_ERR_OVERFLOWED_INT;
107 |   i = int_from_data(data, size);
108 |   /* printf("%" PRId64" okkkk\n", i); */
109 |   *num = num_pool_new(&ind);
110 |   (*num)->val = i;
111 |   (*num)->ind = ind;
112 |   return SN_SUCCESS;
113 | }
114 | 
115 | 
116 | // Return a script num only if it's still a 4-byte integer
117 | enum sn_result sn_from_val(struct val val, struct num ** sn) {
118 | 
119 |   switch (val.type) {
120 |   case VT_SMALLINT:
121 |   case VT_SCRIPTNUM:
122 |     *sn = num_pool_get(val.ind);
123 |     assert((*sn)->ind == val.ind);
124 |     assert(*sn);
125 | 
126 |     // we're trying to return a scriptnum that is larger than 4 bytes. This is not
127 |     // a valid scriptnum at this point. return an error.
128 |     if (sn_overflowed(*sn)) {
129 |       *sn = 0;
130 |       return SN_ERR_OVERFLOWED_INT;
131 |     }
132 | 
133 |     if (val.type == VT_SMALLINT)
134 |       (*sn)->val = val.ind;
135 | 
136 |     return SN_SUCCESS;
137 |   case VT_RAW:
138 |   case VT_DATA: {
139 |     u8 *data;
140 |     u32 size;
141 |     enum sn_result res;
142 |     assert(val.ind != -1);
143 |     data = byte_pool_get(val.ind, &size);
144 |     return sn_from_data(data, size, sn);
145 |   }
146 |   }
147 | 
148 |   printf("type: %d\n", val.type);
149 |   assert(!"sn_from_val: unhandled");
150 | 
151 |   return SN_SUCCESS;
152 | }
153 | 
154 | struct val
155 | sn_to_val(struct num *sn) {
156 |   struct val val;
157 |   struct num *snref;
158 |   u16 ind;
159 | 
160 |   if (sn_overflowed(sn)) {
161 |     u16 ind, len;
162 |     static u8 tmp[8];
163 |     sn_serialize(sn, tmp, 8, &len);
164 |     u8 *data = byte_pool_new(len, &ind);
165 |     memcpy(data, tmp, len);
166 |     val.type = VT_DATA;
167 |     val.ind = ind;
168 |   }
169 |   else
170 |   {
171 |     val.type = VT_SCRIPTNUM;
172 |     if (sn->ind > -1)
173 |       val.ind = sn->ind;
174 |     else {
175 |       snref = num_pool_new(&ind);
176 |       snref->val = sn->val;
177 |       val.ind = ind;
178 |     }
179 | 
180 |   }
181 |   return val;
182 | }
183 | 


--------------------------------------------------------------------------------
/deps/tap.c/tap.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | libtap - Write tests in C
  3 | Copyright 2012 Jake Gelbman <gelbman@gmail.com>
  4 | This file is licensed under the GPLv2
  5 | */
  6 | 
  7 | #ifndef __TAP_H__
  8 | #define __TAP_H__
  9 | 
 10 | #ifdef __cplusplus
 11 | extern "C" {
 12 | #endif
 13 | 
 14 | #ifndef va_copy
 15 | #ifdef __va_copy
 16 | #define va_copy __va_copy
 17 | #else
 18 | #define va_copy(d, s) ((d) = (s))
 19 | #endif
 20 | #endif
 21 | 
 22 | #include <stdio.h>
 23 | #include <stdlib.h>
 24 | #include <stdarg.h>
 25 | 
 26 | int     vok_at_loc      (const char *file, int line, int test, const char *fmt,
 27 |                          va_list args);
 28 | int     ok_at_loc       (const char *file, int line, int test, const char *fmt,
 29 |                          ...);
 30 | int     is_at_loc       (const char *file, int line, const char *got,
 31 |                          const char *expected, const char *fmt, ...);
 32 | int     isnt_at_loc     (const char *file, int line, const char *got,
 33 |                          const char *expected, const char *fmt, ...);
 34 | int     cmp_ok_at_loc   (const char *file, int line, int a, const char *op,
 35 |                          int b, const char *fmt, ...);
 36 | int     bail_out        (const char *fmt, ...);
 37 | void    tap_plan        (int tests, const char *fmt, ...);
 38 | int     diag            (const char *fmt, ...);
 39 | int     note            (const char *fmt, ...);
 40 | int     exit_status     (void);
 41 | void    tap_skip        (int n, const char *fmt, ...);
 42 | void    tap_todo        (const char *fmt, ...);
 43 | void    tap_end_todo    (void);
 44 | 
 45 | #define NO_PLAN          -1
 46 | #define SKIP_ALL         -2
 47 | #define ok(...)          ok_at_loc(__FILE__, __LINE__, __VA_ARGS__, NULL)
 48 | #define is(...)          is_at_loc(__FILE__, __LINE__, __VA_ARGS__, NULL)
 49 | #define isnt(...)        isnt_at_loc(__FILE__, __LINE__, __VA_ARGS__, NULL)
 50 | #define cmp_ok(...)      cmp_ok_at_loc(__FILE__, __LINE__, __VA_ARGS__, NULL)
 51 | #define plan(...)        tap_plan(__VA_ARGS__, NULL)
 52 | #define done_testing()   return exit_status()
 53 | #define BAIL_OUT(...)    bail_out(0, "" __VA_ARGS__, NULL)
 54 | #define pass(...)        ok(1, "" __VA_ARGS__)
 55 | #define fail(...)        ok(0, "" __VA_ARGS__)
 56 | 
 57 | #define skip(test, ...)  do {if (test) {tap_skip(__VA_ARGS__, NULL); break;}
 58 | #define end_skip         } while (0)
 59 | 
 60 | #define todo(...)        tap_todo(0, "" __VA_ARGS__, NULL)
 61 | #define end_todo         tap_end_todo()
 62 | 
 63 | #define dies_ok(...)     dies_ok_common(1, __VA_ARGS__)
 64 | #define lives_ok(...)    dies_ok_common(0, __VA_ARGS__)
 65 | 
 66 | #ifdef _WIN32
 67 | #define like(...)        tap_skip(1, "like is not implemented on Windows")
 68 | #define unlike           tap_skip(1, "unlike is not implemented on Windows")
 69 | #define dies_ok_common(...) \
 70 |                          tap_skip(1, "Death detection is not supported on Windows")
 71 | #else
 72 | #define like(...)        like_at_loc(1, __FILE__, __LINE__, __VA_ARGS__, NULL)
 73 | #define unlike(...)      like_at_loc(0, __FILE__, __LINE__, __VA_ARGS__, NULL)
 74 | int     like_at_loc     (int for_match, const char *file, int line,
 75 |                          const char *got, const char *expected,
 76 |                          const char *fmt, ...);
 77 | #include <unistd.h>
 78 | #include <sys/types.h>
 79 | #include <sys/wait.h>
 80 | int tap_test_died (int status);
 81 | #define dies_ok_common(for_death, code, ...)                \
 82 |     do {                                                    \
 83 |         int cpid;                                           \
 84 |         int it_died;                                        \
 85 |         tap_test_died(1);                                   \
 86 |         cpid = fork();                                      \
 87 |         switch (cpid) {                                     \
 88 |         case -1:                                            \
 89 |             perror("fork error");                           \
 90 |             exit(1);                                        \
 91 |         case 0:                                             \
 92 |             close(1);                                       \
 93 |             close(2);                                       \
 94 |             code                                            \
 95 |             tap_test_died(0);                               \
 96 |             exit(0);                                        \
 97 |         }                                                   \
 98 |         if (waitpid(cpid, NULL, 0) < 0) {                   \
 99 |             perror("waitpid error");                        \
100 |             exit(1);                                        \
101 |         }                                                   \
102 |         it_died = tap_test_died(0);                         \
103 |         if (!it_died)                                       \
104 |             {code}                                          \
105 |         ok(for_death ? it_died : !it_died, "" __VA_ARGS__); \
106 |     } while (0)
107 | #endif
108 | 
109 | #ifdef __cplusplus
110 | }
111 | #endif
112 | 
113 | #endif
114 | 
115 | 


--------------------------------------------------------------------------------
/op.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef BCS_OP_H
  3 | #define BCS_OP_H
  4 | 
  5 | #include "misc.h"
  6 | #include "stack.h"
  7 | #include "val.h"
  8 | #include <stdio.h>
  9 | #include <math.h>
 10 | 
 11 | enum opcode
 12 | {
 13 |     // push value
 14 |     OP_0 = 0x00,
 15 |     OP_FALSE = OP_0,
 16 |     OP_PUSHDATA1 = 0x4c,
 17 |     OP_PUSHDATA2 = 0x4d,
 18 |     OP_PUSHDATA4 = 0x4e,
 19 |     OP_1NEGATE = 0x4f,
 20 |     OP_RESERVED = 0x50,
 21 |     OP_1 = 0x51,
 22 |     OP_TRUE=OP_1,
 23 |     OP_2 = 0x52,
 24 |     OP_3 = 0x53,
 25 |     OP_4 = 0x54,
 26 |     OP_5 = 0x55,
 27 |     OP_6 = 0x56,
 28 |     OP_7 = 0x57,
 29 |     OP_8 = 0x58,
 30 |     OP_9 = 0x59,
 31 |     OP_10 = 0x5a,
 32 |     OP_11 = 0x5b,
 33 |     OP_12 = 0x5c,
 34 |     OP_13 = 0x5d,
 35 |     OP_14 = 0x5e,
 36 |     OP_15 = 0x5f,
 37 |     OP_16 = 0x60,
 38 | 
 39 |     // control
 40 |     OP_NOP = 0x61,
 41 |     OP_VER = 0x62,
 42 |     OP_IF = 0x63,
 43 |     OP_NOTIF = 0x64,
 44 |     OP_VERIF = 0x65,
 45 |     OP_VERNOTIF = 0x66,
 46 |     OP_ELSE = 0x67,
 47 |     OP_ENDIF = 0x68,
 48 |     OP_VERIFY = 0x69,
 49 |     OP_RETURN = 0x6a,
 50 | 
 51 |     // stack ops
 52 |     OP_TOALTSTACK = 0x6b,
 53 |     OP_FROMALTSTACK = 0x6c,
 54 |     OP_2DROP = 0x6d,
 55 |     OP_2DUP = 0x6e,
 56 |     OP_3DUP = 0x6f,
 57 |     OP_2OVER = 0x70,
 58 |     OP_2ROT = 0x71,
 59 |     OP_2SWAP = 0x72,
 60 |     OP_IFDUP = 0x73,
 61 |     OP_DEPTH = 0x74,
 62 |     OP_DROP = 0x75,
 63 |     OP_DUP = 0x76,
 64 |     OP_NIP = 0x77,
 65 |     OP_OVER = 0x78,
 66 |     OP_PICK = 0x79,
 67 |     OP_ROLL = 0x7a,
 68 |     OP_ROT = 0x7b,
 69 |     OP_SWAP = 0x7c,
 70 |     OP_TUCK = 0x7d,
 71 | 
 72 |     // splice ops
 73 |     OP_CAT = 0x7e,
 74 |     OP_SUBSTR = 0x7f,
 75 |     OP_LEFT = 0x80,
 76 |     OP_RIGHT = 0x81,
 77 |     OP_SIZE = 0x82,
 78 | 
 79 |     // bit logic
 80 |     OP_INVERT = 0x83,
 81 |     OP_AND = 0x84,
 82 |     OP_OR = 0x85,
 83 |     OP_XOR = 0x86,
 84 |     OP_EQUAL = 0x87,
 85 |     OP_EQUALVERIFY = 0x88,
 86 |     OP_RESERVED1 = 0x89,
 87 |     OP_RESERVED2 = 0x8a,
 88 | 
 89 |     // numeric
 90 |     OP_1ADD = 0x8b,
 91 |     OP_1SUB = 0x8c,
 92 |     OP_2MUL = 0x8d,
 93 |     OP_2DIV = 0x8e,
 94 |     OP_NEGATE = 0x8f,
 95 |     OP_ABS = 0x90,
 96 |     OP_NOT = 0x91,
 97 |     OP_0NOTEQUAL = 0x92,
 98 | 
 99 |     OP_ADD = 0x93,
100 |     OP_SUB = 0x94,
101 |     OP_MUL = 0x95,
102 |     OP_DIV = 0x96,
103 |     OP_MOD = 0x97,
104 |     OP_LSHIFT = 0x98,
105 |     OP_RSHIFT = 0x99,
106 | 
107 |     OP_BOOLAND = 0x9a,
108 |     OP_BOOLOR = 0x9b,
109 |     OP_NUMEQUAL = 0x9c,
110 |     OP_NUMEQUALVERIFY = 0x9d,
111 |     OP_NUMNOTEQUAL = 0x9e,
112 |     OP_LESSTHAN = 0x9f,
113 |     OP_GREATERTHAN = 0xa0,
114 |     OP_LESSTHANOREQUAL = 0xa1,
115 |     OP_GREATERTHANOREQUAL = 0xa2,
116 |     OP_MIN = 0xa3,
117 |     OP_MAX = 0xa4,
118 | 
119 |     OP_WITHIN = 0xa5,
120 | 
121 |     // crypto
122 |     OP_RIPEMD160 = 0xa6,
123 |     OP_SHA1 = 0xa7,
124 |     OP_SHA256 = 0xa8,
125 |     OP_HASH160 = 0xa9,
126 |     OP_HASH256 = 0xaa,
127 |     OP_CODESEPARATOR = 0xab,
128 |     OP_CHECKSIG = 0xac,
129 |     OP_CHECKSIGVERIFY = 0xad,
130 |     OP_CHECKMULTISIG = 0xae,
131 |     OP_CHECKMULTISIGVERIFY = 0xaf,
132 | 
133 |     // expansion
134 |     OP_NOP1 = 0xb0,
135 |     OP_CHECKLOCKTIMEVERIFY = 0xb1,
136 |     OP_NOP2 = OP_CHECKLOCKTIMEVERIFY,
137 |     OP_CHECKSEQUENCEVERIFY = 0xb2,
138 |     OP_NOP3 = OP_CHECKSEQUENCEVERIFY,
139 |     OP_NOP4 = 0xb3,
140 |     OP_NOP5 = 0xb4,
141 |     OP_NOP6 = 0xb5,
142 |     OP_NOP7 = 0xb6,
143 |     OP_NOP8 = 0xb7,
144 |     OP_NOP9 = 0xb8,
145 |     OP_NOP10 = 0xb9,
146 | 
147 | 
148 |     // template matching params
149 |     OP_SMALLINTEGER = 0xfa,
150 |     OP_PUBKEYS = 0xfb,
151 |     OP_PUBKEYHASH = 0xfd,
152 |     OP_PUBKEY = 0xfe,
153 | 
154 |     OP_INVALIDOPCODE = 0xff,
155 | };
156 | 
157 | 
158 | enum opcode_token
159 | {
160 |     // push value
161 |     _OP_0=1,
162 |     _OP_FALSE,
163 |     _OP_PUSHDATA1,
164 |     _OP_PUSHDATA2,
165 |     _OP_PUSHDATA4,
166 |     _OP_1NEGATE,
167 |     _OP_RESERVED,
168 |     _OP_1,
169 |     _OP_TRUE,
170 |     _OP_2,
171 |     _OP_3,
172 |     _OP_4,
173 |     _OP_5,
174 |     _OP_6,
175 |     _OP_7,
176 |     _OP_8,
177 |     _OP_9,
178 |     _OP_10,
179 |     _OP_11,
180 |     _OP_12,
181 |     _OP_13,
182 |     _OP_14,
183 |     _OP_15,
184 |     _OP_16,
185 | 
186 |     // control
187 |     _OP_NOP,
188 |     _OP_VER,
189 |     _OP_IF,
190 |     _OP_NOTIF,
191 |     _OP_VERIF,
192 |     _OP_VERNOTIF,
193 |     _OP_ELSE,
194 |     _OP_ENDIF,
195 |     _OP_VERIFY,
196 |     _OP_RETURN,
197 | 
198 |     // stack ops
199 |     _OP_TOALTSTACK,
200 |     _OP_FROMALTSTACK,
201 |     _OP_2DROP,
202 |     _OP_2DUP,
203 |     _OP_3DUP,
204 |     _OP_2OVER,
205 |     _OP_2ROT,
206 |     _OP_2SWAP,
207 |     _OP_IFDUP,
208 |     _OP_DEPTH,
209 |     _OP_DROP,
210 |     _OP_DUP,
211 |     _OP_NIP,
212 |     _OP_OVER,
213 |     _OP_PICK,
214 |     _OP_ROLL,
215 |     _OP_ROT,
216 |     _OP_SWAP,
217 |     _OP_TUCK,
218 | 
219 |     // splice ops
220 |     _OP_CAT,
221 |     _OP_SUBSTR,
222 |     _OP_LEFT,
223 |     _OP_RIGHT,
224 |     _OP_SIZE,
225 | 
226 |     // bit logic
227 |     _OP_INVERT,
228 |     _OP_AND,
229 |     _OP_OR,
230 |     _OP_XOR,
231 |     _OP_EQUAL,
232 |     _OP_EQUALVERIFY,
233 |     _OP_RESERVED1,
234 |     _OP_RESERVED2,
235 | 
236 |     // numeric
237 |     _OP_1ADD,
238 |     _OP_1SUB,
239 |     _OP_2MUL,
240 |     _OP_2DIV,
241 |     _OP_NEGATE,
242 |     _OP_ABS,
243 |     _OP_NOT,
244 |     _OP_0NOTEQUAL,
245 | 
246 |     _OP_ADD,
247 |     _OP_SUB,
248 |     _OP_MUL,
249 |     _OP_DIV,
250 |     _OP_MOD,
251 |     _OP_LSHIFT,
252 |     _OP_RSHIFT,
253 | 
254 |     _OP_BOOLAND,
255 |     _OP_BOOLOR,
256 |     _OP_NUMEQUAL,
257 |     _OP_NUMEQUALVERIFY,
258 |     _OP_NUMNOTEQUAL,
259 |     _OP_LESSTHAN,
260 |     _OP_GREATERTHAN,
261 |     _OP_LESSTHANOREQUAL,
262 |     _OP_GREATERTHANOREQUAL,
263 |     _OP_MIN,
264 |     _OP_MAX,
265 | 
266 |     _OP_WITHIN,
267 | 
268 |     // crypto
269 |     _OP_RIPEMD160,
270 |     _OP_SHA1,
271 |     _OP_SHA256,
272 |     _OP_HASH160,
273 |     _OP_HASH256,
274 |     _OP_CODESEPARATOR,
275 |     _OP_CHECKSIG,
276 |     _OP_CHECKSIGVERIFY,
277 |     _OP_CHECKMULTISIG,
278 |     _OP_CHECKMULTISIGVERIFY,
279 | 
280 |     // expansion
281 |     _OP_NOP1,
282 |     _OP_CHECKLOCKTIMEVERIFY,
283 |     _OP_NOP2,
284 |     _OP_CHECKSEQUENCEVERIFY,
285 |     _OP_NOP3,
286 |     _OP_NOP4,
287 |     _OP_NOP5,
288 |     _OP_NOP6,
289 |     _OP_NOP7,
290 |     _OP_NOP8,
291 |     _OP_NOP9,
292 |     _OP_NOP10,
293 | 
294 | 
295 |     // template matching params
296 |     _OP_SMALLINTEGER,
297 |     _OP_PUBKEYS,
298 |     _OP_PUBKEYHASH,
299 |     _OP_PUBKEY,
300 | 
301 |     _OP_INVALIDOPCODE,
302 | };
303 | 
304 | // Maximum value that an opcode can be
305 | static const unsigned int MAX_OPCODE = OP_NOP10;
306 | 
307 | void         op_add(enum opcode);
308 | const char * op_name(enum opcode);
309 | enum opcode  op_tokenize(char *);
310 | void         val_print(struct val);
311 | const char * val_name(struct val);
312 | 
313 | 
314 | 
315 | #endif /* BCS_OP_H */
316 | 


--------------------------------------------------------------------------------
/main.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <stdio.h>
  3 | #include <stdlib.h>
  4 | #include <string.h>
  5 | #include <errno.h>
  6 | 
  7 | #include "stack.h"
  8 | #include "script.h"
  9 | #include "alloc.h"
 10 | #include "util.h"
 11 | 
 12 | extern int yyparse();
 13 | extern FILE* yyin;
 14 | 
 15 | char * g_reader_buf;
 16 | char * g_reader_buf_top;
 17 | struct stack g_reader_stack;
 18 | u32 g_reader_buf_cap;
 19 | int yy_scan_string(const char *);
 20 | 
 21 | 
 22 | void yyerror(const char* s);
 23 | 
 24 | #define streq(a,b) strcmp(a,b) == 0
 25 | 
 26 | 
 27 | void parse_error(char* err) {
 28 |   fprintf(stderr, "[btcs] parse error: %s\n", err);
 29 |   exit(1);
 30 | }
 31 | 
 32 | #define COMPILE_SHOW_SCRIPT      (1 << 0)
 33 | #define COMPILE_SHOW_SCRIPT_HEX  (1 << 1)
 34 | #define COMPILE_SHOW_STACK       (1 << 2)
 35 | #define COMPILE_SHOW_STACK_HEX   (1 << 3)
 36 | #define COMPILE_SHOW_RESULTS     (1 << 4)
 37 | #define COMPILE_SHOW_LABELS      (1 << 5)
 38 | #define COMPILE_SHOW_ALL         0x3F
 39 | 
 40 | static int compile(int compile_options, int argc, const char *argv[])
 41 | {
 42 |   yyin = stdin;
 43 | 
 44 |   struct result result;
 45 |   /* size_t size; */
 46 |   size_t bufsize = MAX_STACK_SIZE * MAX_STACK_SIZE;
 47 |   int i;
 48 |   int compiled_len;
 49 |   u8 *buf = (u8*)malloc(bufsize);
 50 |   struct stack tmp_stack;
 51 |   alloc_arenas();
 52 |   stack_init(&tmp_stack);
 53 |   stack_init(&g_reader_stack);
 54 | 
 55 |   if (argc > 1) {
 56 |     for (i = 1; i < argc; ++i) {
 57 |       yy_scan_string(argv[i]);
 58 |       yyparse();
 59 |     }
 60 |   }
 61 |   else {
 62 |     do {
 63 |       yyparse();
 64 |     } while(!feof(yyin));
 65 |   }
 66 | 
 67 |   bool nol = (compile_options & COMPILE_SHOW_LABELS) == 0;
 68 | 
 69 |   /* size = g_reader_buf_top - g_reader_buf; */
 70 |   if (compile_options & COMPILE_SHOW_SCRIPT) {
 71 | 	  if (compile_options & COMPILE_SHOW_LABELS)
 72 | 		printf("script      ");
 73 | 	  script_print_vals(&g_reader_stack);
 74 |   }
 75 | 
 76 |   script_serialize(&g_reader_stack, buf, bufsize, &compiled_len);
 77 |   script_eval(buf, compiled_len, &tmp_stack, &result);
 78 | 
 79 |   if (compile_options & COMPILE_SHOW_SCRIPT_HEX) {
 80 | 	  if (compile_options & COMPILE_SHOW_LABELS)
 81 | 		printf("script_hex  ");
 82 | 	  for(i = 0; i < compiled_len; ++i)
 83 | 		  printf("%02x", buf[i]);
 84 | 	  printf("\n");
 85 |   }
 86 | 
 87 |   if (compile_options & COMPILE_SHOW_STACK) {
 88 | 	  if (compile_options & COMPILE_SHOW_LABELS)
 89 | 		printf("stack       ");
 90 | 	  script_print_vals(&tmp_stack);
 91 |   }
 92 | 
 93 |   stack_serialize(&tmp_stack, buf, bufsize, &compiled_len);
 94 | 
 95 |   if (compile_options & COMPILE_SHOW_STACK_HEX) {
 96 | 	  if (compile_options & COMPILE_SHOW_LABELS)
 97 | 		printf("stack_hex   ");
 98 | 	  for(i = 0; i < compiled_len; ++i)
 99 | 		  printf("%02x", buf[i]);
100 | 	  printf("\n");
101 |   }
102 | 
103 |   if (compile_options & COMPILE_SHOW_RESULTS) {
104 | 	  if (compile_options & COMPILE_SHOW_LABELS)
105 | 		printf("results     ");
106 | 	  if (result.error)
107 | 		  printf("error:%d:%s:%s", result.op_count, result.error,
108 | 			 op_name(result.last_op));
109 | 	  else
110 | 		  printf("success");
111 | 	  printf("\n");
112 |   }
113 | 
114 |   stack_free(&g_reader_stack);
115 |   stack_free(&tmp_stack);
116 |   free_arenas(0);
117 | 
118 |   return !!result.error;
119 | }
120 | 
121 | static void fail(int err, const char *msg)
122 | {
123 | 	fprintf(stderr, "error: %s\n", msg);
124 | 	exit(err);
125 | }
126 | 
127 | 
128 | static int decompile(const char *str, size_t *strlen, bool abbrev_data)
129 | {
130 | 	static u8 buf[10000];
131 | 
132 | 	hex_decode(str, strlen, buf, sizeof(buf));
133 | 
134 | 	if (*strlen % 2 != 0)
135 | 		return 0;
136 | 
137 | 	size_t nbytes = *strlen / 2;
138 | 
139 | 	script_print(buf, nbytes, abbrev_data);
140 | 
141 | 	return 1;
142 | }
143 | 
144 | 
145 | static void usage()
146 | {
147 | 	fprintf(stderr, "usage: btcs [OPTIONS] <script>\n\n");
148 | 	fprintf(stderr, "   OPTIONS\n\n");
149 | 	fprintf(stderr, "      -d,--decompile    decompile a base16 string to bitcoin script\n");
150 | 	exit(1);
151 | }
152 | 
153 | static u32 count_bits(u32 n)
154 | {
155 | 	u32 count = 0;
156 | 	while (n) {
157 | 		n &= (n-1) ;
158 | 		count++;
159 | 	}
160 | 	return count;
161 | }
162 | 
163 | int main(int argc, const char *argv[])
164 | {
165 | 	static u8 buf[20000];
166 | 
167 | 	bool is_decompile = false;
168 | 	const char *input = NULL;
169 | 	size_t written;
170 | 	bool abbrev_data = false;
171 | 	int compile_options = 0;
172 | 	int last_opt = 0;
173 | 	int hide_labels = -1;
174 | 
175 | 	if (argc == 2 && (streq(argv[1], "-h") || streq(argv[1], "--help")))
176 | 		usage();
177 | 
178 | 	for (int i = 1; i < argc; i++) {
179 | 		if (streq(argv[i], "-d") || streq(argv[i], "--decompile"))
180 | 			is_decompile = true;
181 | 		else if (streq(argv[i], "-sh") || streq(argv[i], "--script-hex"))
182 | 			compile_options |= COMPILE_SHOW_SCRIPT_HEX;
183 | 		else if (streq(argv[i], "-s") || streq(argv[i], "--script"))
184 | 			compile_options |= COMPILE_SHOW_SCRIPT;
185 | 		else if (streq(argv[i], "-t") || streq(argv[i], "--stack"))
186 | 			compile_options |= COMPILE_SHOW_STACK;
187 | 		else if (streq(argv[i], "-th") || streq(argv[i], "--stack-hex"))
188 | 			compile_options |= COMPILE_SHOW_STACK_HEX;
189 | 		else if (streq(argv[i], "-r") || streq(argv[i], "--results"))
190 | 			compile_options |= COMPILE_SHOW_RESULTS;
191 | 		else if (streq(argv[i], "-l") || streq(argv[i], "--hide-labels"))
192 | 			hide_labels = 1;
193 | 		else if (streq(argv[i], "+l") || streq(argv[i], "--show-labels"))
194 | 			hide_labels = 0;
195 | 		else if (streq(argv[i], "-a") || streq(argv[i], "--abbreviate-data"))
196 | 			abbrev_data = true;
197 | 		else {
198 | 			last_opt = i-1;
199 | 			input = argv[i];
200 | 			break;
201 | 		}
202 | 	}
203 | 
204 | 	if (is_decompile) {
205 | 		// we have stdin
206 | 		char *line = NULL;
207 | 		ssize_t len = 0, prevlen;
208 | 		size_t n;
209 | 		int ok;
210 | 		bool failed = false;
211 | 
212 | 		if (input == NULL) {
213 | 			while ((len = getline(&line, &n, stdin)) != -1) {
214 | 				len--;
215 | 				prevlen = len;
216 | 				ok = decompile(line, (size_t*)&len, abbrev_data);
217 | 
218 | 				printf("%.*s\n", (int)(prevlen - len), line+len);
219 | 
220 | 				if (!ok) {
221 | 					failed = true;
222 | 					fprintf(stderr, "failed to decompile\n");
223 | 				}
224 | 			}
225 | 		}
226 | 		else {
227 | 			ok = read_arg_or_stdin(input, buf, sizeof(buf), &written);
228 | 
229 | 			if (!ok)
230 | 				fail(4, "failed to read input arg (too big?)");
231 | 
232 | 			ok = decompile((const char *)buf, &written, abbrev_data);
233 | 			printf("\n");
234 | 
235 | 			if (!ok) {
236 | 				fprintf(stderr, "failed to decompile\n");
237 | 				failed = true;
238 | 			}
239 | 		}
240 | 
241 | 		if (failed)
242 | 			exit(5);
243 | 
244 | 
245 | 	}
246 | 	else {
247 | 		if (!compile_options)
248 | 			compile_options = COMPILE_SHOW_ALL;
249 | 
250 | 		if (hide_labels == -1)
251 | 			hide_labels = count_bits(compile_options) == 1;
252 | 
253 | 		if (hide_labels)
254 | 			compile_options &= ~COMPILE_SHOW_LABELS;
255 | 		else
256 | 			compile_options |= COMPILE_SHOW_LABELS;
257 | 
258 | 		exit( compile(compile_options, argc - last_opt, argv + last_opt) );
259 | 	}
260 | }
261 | 
262 | void yyerror(const char* s) {
263 |   fprintf(stderr, "Parse error: %s\n", s);
264 |   exit(1);
265 | }
266 | 


--------------------------------------------------------------------------------
/test.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "script.h"
  3 | #include "op.h"
  4 | #include "alloc.h"
  5 | #include "valstack.h"
  6 | #include "compiler.h"
  7 | #include "tap.c/tap.h"
  8 | 
  9 | typedef void (program)(struct stack *script, struct stack *stack,\
 10 |                        struct result *result, struct stack *expected);
 11 | 
 12 | #define RUNTEST(test) run_test(script, stack, expected, result, test)
 13 | #define TEST(test) static inline void test(struct stack *script UNUSED, \
 14 |                                            struct stack *stack, \
 15 |                                            struct result *result,   \
 16 |                                            struct stack *expected UNUSED  \
 17 |                                           )
 18 | 
 19 | 
 20 | static void
 21 | cmp_data(const u8 *a, const u8 *b, int alen, int blen, const char *msg) {
 22 |   int i = 0;
 23 |   if (memcmp(a, b, blen) != 0) {
 24 |     printf("#\n# Failed data cmp test\n# > ");
 25 |     for (i = 0; i < alen; ++i)
 26 |       printf("%02x ", a[i] & 0xff);
 27 | 
 28 |     printf("\n# > ");
 29 |     for (i = 0; i < blen; ++i)
 30 |       printf("%02x ", b[i] & 0xff);
 31 | 
 32 |     printf("\n#\n");
 33 |     fail("%s", msg);
 34 |   }
 35 |   else
 36 |     pass("%s", msg);
 37 | }
 38 | /* static void */
 39 | /* test_nip(struct stack *stack, struct stack *expected) { */
 40 | /*   stack_push_op(OP_1); */
 41 | /* } */
 42 | 
 43 | 
 44 | static inline void
 45 | ok_stacks_equal(struct stack *s1, struct stack *s2, const char *context) {
 46 |   void **b1 = s1->bottom;
 47 |   void **b2 = s2->bottom;
 48 |   struct val v1;
 49 |   struct val v2;
 50 | 
 51 |   size_t s1size = stack_size(s1);
 52 |   size_t s2size = stack_size(s2);
 53 | 
 54 |   cmp_ok(s1size, "==", s2size, "%s: expected stack size", context);
 55 | 
 56 |   for (size_t i = 0; i < s1size; ++i) {
 57 |     v1 = stack_top_val(s1, i);
 58 |     v2 = stack_top_val(s2, i);
 59 | 
 60 |     if (!val_eq(v1, v2)) {
 61 |       is(val_name(v1), val_name(v2), "%s: stack vals match", context);
 62 |     }
 63 |   }
 64 | }
 65 | 
 66 | TEST(test_simple) {
 67 |   u8 in_script[] = { OP_1 };
 68 | 
 69 |   script_eval(in_script, 1, stack, result);
 70 |   ok(!result->error, "test_simple: no errors");
 71 |   ok(result->op_count == 1, "test_simple: op count is 1");
 72 |   ok(result->last_op == OP_1, "test_simple: last op is OP_1");
 73 | 
 74 |   stack_push_val(expected, smallintval(1));
 75 |   ok_stacks_equal(stack, expected, "test_simple");
 76 | }
 77 | 
 78 | TEST(test_nip) {
 79 |   u8 in_script[] = { OP_1, OP_2, OP_NIP };
 80 | 
 81 |   script_eval(in_script, ARRAY_SIZE(in_script), stack, result);
 82 |   ok(!result->error, "test_nip: no errors returned");
 83 |   ok(result->op_count == 3, "test_nip: op_count is 3");
 84 | 
 85 |   stack_push_val(expected, smallintval(2));
 86 |   ok_stacks_equal(stack, expected, "test_nip");
 87 | }
 88 | 
 89 | TEST(test_2dup_not_enough_input) {
 90 |   u8 in_script[] = { OP_1, OP_2DUP };
 91 | 
 92 |   int res = script_eval(in_script, ARRAY_SIZE(in_script), stack, result);
 93 |   ok(res == 0, "2dup fail on small stack");
 94 | }
 95 | 
 96 | TEST(negative_integer) {
 97 |   static u8 buf[6];
 98 |   int buflen;
 99 |   u8 expected_in[] = { 0x01, 0x82 };
100 |   u8 expected_out[] = { 0x82 };
101 |   script_eval(expected_in, sizeof(expected_in), stack, result);
102 |   stack_serialize(stack, buf, sizeof(buf), &buflen);
103 |   cmp_data(buf, expected_out, buflen, sizeof(expected_out), "negative 2 serializes ok");
104 | }
105 | 
106 | TEST(add_negative_two) {
107 |   static u8 buf[12];
108 |   int len;
109 |   static u8 in_script[] = { 0x01, 0x82, 0x01, 0x82, OP_ADD };
110 |   static u8 expected_out[] = { 0x84 };
111 |   script_eval(in_script, ARRAY_SIZE(in_script), stack, result);
112 |   stack_serialize(stack, buf, sizeof(buf), &len);
113 |   cmp_data(buf, expected_out, len, ARRAY_SIZE(expected_out), "add negative two twice");
114 | }
115 | 
116 | TEST(big_int_serializes_ok) {
117 |   int len;
118 |   static u8 buf[12];
119 |   static u8 expected_in[] = { 0x04, 0xff, 0xff, 0xff, 0x7f,
120 |                               0x04, 0xff, 0xff, 0xff, 0x7f, OP_ADD };
121 |   static u8 expected_out[] = { 0xfe, 0xff, 0xff, 0xff, 0 };
122 | 
123 |   script_push_int(script, 2147483647LL);
124 |   script_push_int(script, 2147483647LL);
125 |   stack_push_op(script, OP_ADD);
126 | 
127 |   script_serialize(script, buf, ARRAY_SIZE(buf), &len);
128 | 
129 |   cmp_data(buf, expected_in, len, ARRAY_SIZE(expected_in),
130 |            "big int input serializes ok");
131 | 
132 |   script_eval(buf, sizeof(expected_in), stack, result);
133 |   stack_serialize(stack, buf, sizeof(buf), &len);
134 | 
135 |   cmp_data(buf, expected_out, len, ARRAY_SIZE(expected_out),
136 |            "big int output serializes ok");
137 | }
138 | 
139 | TEST(test_small_int) {
140 |   int len;
141 |   static u8 buf[6];
142 |   static u8 expected_in[] = { 0x01, 0x7f };
143 |   static u8 expected_out[] = { 0x7f };
144 | 
145 |   script_push_int(script, 127);
146 |   script_serialize(script, buf, sizeof(buf), &len);
147 |   cmp_data(buf, expected_in, len, sizeof(expected_in),
148 |            "small integer input serializes ok");
149 | 
150 |   script_eval(buf, sizeof(expected_in), stack, result);
151 |   stack_serialize(stack, buf, sizeof(buf), &len);
152 |   cmp_data(buf, expected_out, len, sizeof(expected_out),
153 |            "small integer output serializes ok");
154 | }
155 | 
156 | void test_sn_serialize_small() {
157 |   static u8 buf[2] = {0};
158 |   struct num sn;
159 |   static u8 expected_serial[] = { 0x01, 0x7f };
160 |   u16 len;
161 |   sn_from_int(127, &sn);
162 |   sn_serialize(&sn, buf, sizeof(buf), &len);
163 | 
164 |   cmp_data(buf, expected_serial, len, sizeof(expected_serial),
165 |            "small scriptnum (127) serializes ok");
166 | }
167 | 
168 | // TODO test scriptnum overflows
169 | // TODO test scriptnum negative zero boolean logic
170 | // TODO test scriptnum add into overflow + hash
171 | // TODO test unpooled scriptnum index is == -1 for various constructors
172 | 
173 | /* TODO test ops:
174 |  *
175 |  *    OP_1ADD
176 |  *    OP_1SUB
177 |  *    OP_NEGATE
178 |  *    OP_ABS
179 |  *    OP_NOT
180 |  *    OP_0NOTEQUAL
181 |  *
182 |  */
183 | 
184 | 
185 | static inline void
186 | run_test(struct stack *script, struct stack *stack, struct stack *expected,
187 |          struct result *result, program *prog)
188 | {
189 |   stack_clear(script);
190 |   stack_clear(stack);
191 |   stack_clear(expected);
192 |   prog(script, stack, result, expected);
193 | }
194 | 
195 | 
196 | int
197 | main(int argc UNUSED, char *argv[] UNUSED) {
198 |   struct stack _stack, _expected, _script;
199 |   struct result _result;
200 |   struct stack *script   = &_script;
201 |   struct stack *stack    = &_stack;
202 |   struct stack *expected = &_expected;
203 |   struct result *result  = &_result;
204 | 
205 |   alloc_arenas();
206 | 
207 |   plan(15);
208 | 
209 |   stack_init(script);
210 |   stack_init(stack);
211 |   stack_init(expected);
212 | 
213 |   RUNTEST(test_simple);
214 |   RUNTEST(test_nip);
215 |   RUNTEST(test_2dup_not_enough_input);
216 |   RUNTEST(negative_integer);
217 |   RUNTEST(add_negative_two);
218 |   RUNTEST(big_int_serializes_ok);
219 |   RUNTEST(test_small_int);
220 | 
221 |   stack_free(script);
222 |   stack_free(expected);
223 |   stack_free(stack);
224 | 
225 |   free_arenas(0);
226 | 
227 |   done_testing();
228 |   return 0;
229 | }
230 | 


--------------------------------------------------------------------------------
/deps/tap.c/tap.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | libtap - Write tests in C
  3 | Copyright 2012 Jake Gelbman <gelbman@gmail.com>
  4 | This file is licensed under the GPLv2
  5 | */
  6 | 
  7 | #define _DEFAULT_SOURCE 1
  8 | 
  9 | #include <stdio.h>
 10 | #include <stdlib.h>
 11 | #include <stdarg.h>
 12 | #include <string.h>
 13 | #include "tap.h"
 14 | 
 15 | static int expected_tests = NO_PLAN;
 16 | static int failed_tests;
 17 | static int current_test;
 18 | static char *todo_mesg;
 19 | 
 20 | static char *
 21 | vstrdupf (const char *fmt, va_list args) {
 22 |     char *str;
 23 |     int size;
 24 |     va_list args2;
 25 |     va_copy(args2, args);
 26 |     if (!fmt)
 27 |         fmt = "";
 28 |     size = vsnprintf(NULL, 0, fmt, args2) + 2;
 29 |     str = malloc(size);
 30 |     if (!str) {
 31 |         perror("malloc error");
 32 |         exit(1);
 33 |     }
 34 |     vsprintf(str, fmt, args);
 35 |     va_end(args2);
 36 |     return str;
 37 | }
 38 | 
 39 | void
 40 | tap_plan (int tests, const char *fmt, ...) {
 41 |     expected_tests = tests;
 42 |     if (tests == SKIP_ALL) {
 43 |         char *why;
 44 |         va_list args;
 45 |         va_start(args, fmt);
 46 |         why = vstrdupf(fmt, args);
 47 |         va_end(args);
 48 |         printf("1..0 ");
 49 |         note("SKIP %s\n", why);
 50 |         exit(0);
 51 |     }
 52 |     if (tests != NO_PLAN) {
 53 |         printf("1..%d\n", tests);
 54 |     }
 55 | }
 56 | 
 57 | int
 58 | vok_at_loc (const char *file, int line, int test, const char *fmt,
 59 |             va_list args)
 60 | {
 61 |     char *name = vstrdupf(fmt, args);
 62 |     printf("%sok %d", test ? "" : "not ", ++current_test);
 63 |     if (*name)
 64 |         printf(" - %s", name);
 65 |     if (todo_mesg) {
 66 |         printf(" # TODO");
 67 |         if (*todo_mesg)
 68 |             printf(" %s", todo_mesg);
 69 |     }
 70 |     printf("\n");
 71 |     if (!test) {
 72 |         if (*name)
 73 |             diag("  Failed%s test '%s'\n  at %s line %d.",
 74 |                 todo_mesg ? " (TODO)" : "", name, file, line);
 75 |         else
 76 |             diag("  Failed%s test at %s line %d.",
 77 |                 todo_mesg ? " (TODO)" : "", file, line);
 78 |         if (!todo_mesg)
 79 |             failed_tests++;
 80 |     }
 81 |     free(name);
 82 |     return test;
 83 | }
 84 | 
 85 | int
 86 | ok_at_loc (const char *file, int line, int test, const char *fmt, ...) {
 87 |     va_list args;
 88 |     va_start(args, fmt);
 89 |     vok_at_loc(file, line, test, fmt, args);
 90 |     va_end(args);
 91 |     return test;
 92 | }
 93 | 
 94 | static int
 95 | mystrcmp (const char *a, const char *b) {
 96 |     return a == b ? 0 : !a ? -1 : !b ? 1 : strcmp(a, b);
 97 | }
 98 | 
 99 | #define eq(a, b) (!mystrcmp(a, b))
100 | #define ne(a, b) (mystrcmp(a, b))
101 | 
102 | int
103 | is_at_loc (const char *file, int line, const char *got, const char *expected,
104 |            const char *fmt, ...)
105 | {
106 |     int test = eq(got, expected);
107 |     va_list args;
108 |     va_start(args, fmt);
109 |     vok_at_loc(file, line, test, fmt, args);
110 |     va_end(args);
111 |     if (!test) {
112 |         diag("         got: '%s'", got);
113 |         diag("    expected: '%s'", expected);
114 |     }
115 |     return test;
116 | }
117 | 
118 | int
119 | isnt_at_loc (const char *file, int line, const char *got, const char *expected,
120 |              const char *fmt, ...)
121 | {
122 |     int test = ne(got, expected);
123 |     va_list args;
124 |     va_start(args, fmt);
125 |     vok_at_loc(file, line, test, fmt, args);
126 |     va_end(args);
127 |     if (!test) {
128 |         diag("         got: '%s'", got);
129 |         diag("    expected: anything else");
130 |     }
131 |     return test;
132 | }
133 | 
134 | int
135 | cmp_ok_at_loc (const char *file, int line, int a, const char *op, int b,
136 |                const char *fmt, ...)
137 | {
138 |     int test = eq(op, "||") ? a || b
139 |              : eq(op, "&&") ? a && b
140 |              : eq(op, "|")  ? a |  b
141 |              : eq(op, "^")  ? a ^  b
142 |              : eq(op, "&")  ? a &  b
143 |              : eq(op, "==") ? a == b
144 |              : eq(op, "!=") ? a != b
145 |              : eq(op, "<")  ? a <  b
146 |              : eq(op, ">")  ? a >  b
147 |              : eq(op, "<=") ? a <= b
148 |              : eq(op, ">=") ? a >= b
149 |              : eq(op, "<<") ? a << b
150 |              : eq(op, ">>") ? a >> b
151 |              : eq(op, "+")  ? a +  b
152 |              : eq(op, "-")  ? a -  b
153 |              : eq(op, "*")  ? a *  b
154 |              : eq(op, "/")  ? a /  b
155 |              : eq(op, "%")  ? a %  b
156 |              : diag("unrecognized operator '%s'", op);
157 |     va_list args;
158 |     va_start(args, fmt);
159 |     vok_at_loc(file, line, test, fmt, args);
160 |     va_end(args);
161 |     if (!test) {
162 |         diag("    %d", a);
163 |         diag("        %s", op);
164 |         diag("    %d", b);
165 |     }
166 |     return test;
167 | }
168 | 
169 | static void
170 | vdiag_to_fh (FILE *fh, const char *fmt, va_list args) {
171 |     char *mesg, *line;
172 |     int i;
173 |     if (!fmt)
174 |         return;
175 |     mesg = vstrdupf(fmt, args);
176 |     line = mesg;
177 |     for (i = 0; *line; i++) {
178 |         char c = mesg[i];
179 |         if (!c || c == '\n') {
180 |             mesg[i] = '\0';
181 |             fprintf(fh, "# %s\n", line);
182 |             if (!c)
183 |                 break;
184 |             mesg[i] = c;
185 |             line = mesg + i + 1;
186 |         }
187 |     }
188 |     free(mesg);
189 |     return;
190 | }
191 | 
192 | int
193 | diag (const char *fmt, ...) {
194 |     va_list args;
195 |     va_start(args, fmt);
196 |     vdiag_to_fh(stderr, fmt, args);
197 |     va_end(args);
198 |     return 0;
199 | }
200 | 
201 | int
202 | note (const char *fmt, ...) {
203 |     va_list args;
204 |     va_start(args, fmt);
205 |     vdiag_to_fh(stdout, fmt, args);
206 |     va_end(args);
207 |     return 0;
208 | }
209 | 
210 | int
211 | exit_status () {
212 |     int retval = 0;
213 |     if (expected_tests == NO_PLAN) {
214 |         printf("1..%d\n", current_test);
215 |     }
216 |     else if (current_test != expected_tests) {
217 |         diag("Looks like you planned %d test%s but ran %d.",
218 |             expected_tests, expected_tests > 1 ? "s" : "", current_test);
219 |         retval = 255;
220 |     }
221 |     if (failed_tests) {
222 |         diag("Looks like you failed %d test%s of %d run.",
223 |             failed_tests, failed_tests > 1 ? "s" : "", current_test);
224 |         if (expected_tests == NO_PLAN)
225 |             retval = failed_tests;
226 |         else
227 |             retval = expected_tests - current_test + failed_tests;
228 |     }
229 |     return retval;
230 | }
231 | 
232 | int bail_out (const char *fmt, ...) {
233 |     va_list args;
234 |     va_start(args, fmt);
235 |     printf("Bail out!  ");
236 |     vprintf(fmt, args);
237 |     printf("\n");
238 |     va_end(args);
239 |     exit(255);
240 |     return 0;
241 | }
242 | 
243 | void tap_skip (int n, const char *fmt, ...) {
244 |     char *why;
245 |     va_list args;
246 |     va_start(args, fmt);
247 |     why = vstrdupf(fmt, args);
248 |     va_end(args);
249 |     while (n --> 0) {
250 |         printf("ok %d ", ++current_test);
251 |         note("skip %s\n", why);
252 |     }
253 |     free(why);
254 | }
255 | 
256 | void tap_todo (const char *fmt, ...) {
257 |     va_list args;
258 |     va_start(args, fmt);
259 |     todo_mesg = vstrdupf(fmt, args);
260 |     va_end(args);
261 | }
262 | 
263 | void
264 | tap_end_todo () {
265 |     free(todo_mesg);
266 |     todo_mesg = NULL;
267 | }
268 | 
269 | #ifndef _WIN32
270 | #include <sys/mman.h>
271 | #include <sys/param.h>
272 | #include <regex.h>
273 | 
274 | #if defined __APPLE__ || defined BSD
275 | #define MAP_ANONYMOUS MAP_ANON
276 | #endif
277 | 
278 | /* Create a shared memory int to keep track of whether a piece of code executed
279 | dies. to be used in the dies_ok and lives_ok macros.  */
280 | int
281 | tap_test_died (int status) {
282 |     static int *test_died = NULL;
283 |     int prev;
284 |     if (!test_died) {
285 |         test_died = mmap(0, sizeof (int), PROT_READ | PROT_WRITE,
286 |                          MAP_SHARED | MAP_ANONYMOUS, -1, 0);
287 |         *test_died = 0;
288 |     }
289 |     prev = *test_died;
290 |     *test_died = status;
291 |     return prev;
292 | }
293 | 
294 | int
295 | like_at_loc (int for_match, const char *file, int line, const char *got,
296 |              const char *expected, const char *fmt, ...)
297 | {
298 |     int test;
299 |     regex_t re;
300 |     va_list args;
301 |     int err = regcomp(&re, expected, REG_EXTENDED);
302 |     if (err) {
303 |         char errbuf[256];
304 |         regerror(err, &re, errbuf, sizeof errbuf);
305 |         fprintf(stderr, "Unable to compile regex '%s': %s at %s line %d\n",
306 |                         expected, errbuf, file, line);
307 |         exit(255);
308 |     }
309 |     err = regexec(&re, got, 0, NULL, 0);
310 |     regfree(&re);
311 |     test = for_match ? !err : err;
312 |     va_start(args, fmt);
313 |     vok_at_loc(file, line, test, fmt, args);
314 |     va_end(args);
315 |     if (!test) {
316 |         if (for_match) {
317 |             diag("                   '%s'", got);
318 |             diag("    doesn't match: '%s'", expected);
319 |         }
320 |         else {
321 |             diag("                   '%s'", got);
322 |             diag("          matches: '%s'", expected);
323 |         }
324 |     }
325 |     return test;
326 | }
327 | #endif
328 | 
329 | 


--------------------------------------------------------------------------------
/endian.h:
--------------------------------------------------------------------------------
  1 | /* CC0 (Public domain) */
  2 | #ifndef CCAN_ENDIAN_H
  3 | #define CCAN_ENDIAN_H
  4 | #include <stdint.h>
  5 | 
  6 | /**
  7 |  * BSWAP_16 - reverse bytes in a constant uint16_t value.
  8 |  * @val: constant value whose bytes to swap.
  9 |  *
 10 |  * Designed to be usable in constant-requiring initializers.
 11 |  *
 12 |  * Example:
 13 |  *	struct mystruct {
 14 |  *		char buf[BSWAP_16(0x1234)];
 15 |  *	};
 16 |  */
 17 | #define BSWAP_16(val)				\
 18 | 	((((uint16_t)(val) & 0x00ff) << 8)	\
 19 | 	 | (((uint16_t)(val) & 0xff00) >> 8))
 20 | 
 21 | /**
 22 |  * BSWAP_32 - reverse bytes in a constant uint32_t value.
 23 |  * @val: constant value whose bytes to swap.
 24 |  *
 25 |  * Designed to be usable in constant-requiring initializers.
 26 |  *
 27 |  * Example:
 28 |  *	struct mystruct {
 29 |  *		char buf[BSWAP_32(0xff000000)];
 30 |  *	};
 31 |  */
 32 | #define BSWAP_32(val)					\
 33 | 	((((uint32_t)(val) & 0x000000ff) << 24)		\
 34 | 	 | (((uint32_t)(val) & 0x0000ff00) << 8)		\
 35 | 	 | (((uint32_t)(val) & 0x00ff0000) >> 8)		\
 36 | 	 | (((uint32_t)(val) & 0xff000000) >> 24))
 37 | 
 38 | /**
 39 |  * BSWAP_64 - reverse bytes in a constant uint64_t value.
 40 |  * @val: constantvalue whose bytes to swap.
 41 |  *
 42 |  * Designed to be usable in constant-requiring initializers.
 43 |  *
 44 |  * Example:
 45 |  *	struct mystruct {
 46 |  *		char buf[BSWAP_64(0xff00000000000000ULL)];
 47 |  *	};
 48 |  */
 49 | #define BSWAP_64(val)						\
 50 | 	((((uint64_t)(val) & 0x00000000000000ffULL) << 56)	\
 51 | 	 | (((uint64_t)(val) & 0x000000000000ff00ULL) << 40)	\
 52 | 	 | (((uint64_t)(val) & 0x0000000000ff0000ULL) << 24)	\
 53 | 	 | (((uint64_t)(val) & 0x00000000ff000000ULL) << 8)	\
 54 | 	 | (((uint64_t)(val) & 0x000000ff00000000ULL) >> 8)	\
 55 | 	 | (((uint64_t)(val) & 0x0000ff0000000000ULL) >> 24)	\
 56 | 	 | (((uint64_t)(val) & 0x00ff000000000000ULL) >> 40)	\
 57 | 	 | (((uint64_t)(val) & 0xff00000000000000ULL) >> 56))
 58 | 
 59 | #if HAVE_BYTESWAP_H
 60 | #include <byteswap.h>
 61 | #else
 62 | /**
 63 |  * bswap_16 - reverse bytes in a uint16_t value.
 64 |  * @val: value whose bytes to swap.
 65 |  *
 66 |  * Example:
 67 |  *	// Output contains "1024 is 4 as two bytes reversed"
 68 |  *	printf("1024 is %u as two bytes reversed\n", bswap_16(1024));
 69 |  */
 70 | static inline uint16_t bswap_16(uint16_t val)
 71 | {
 72 | 	return BSWAP_16(val);
 73 | }
 74 | 
 75 | /**
 76 |  * bswap_32 - reverse bytes in a uint32_t value.
 77 |  * @val: value whose bytes to swap.
 78 |  *
 79 |  * Example:
 80 |  *	// Output contains "1024 is 262144 as four bytes reversed"
 81 |  *	printf("1024 is %u as four bytes reversed\n", bswap_32(1024));
 82 |  */
 83 | static inline uint32_t bswap_32(uint32_t val)
 84 | {
 85 | 	return BSWAP_32(val);
 86 | }
 87 | #endif /* !HAVE_BYTESWAP_H */
 88 | 
 89 | #if !HAVE_BSWAP_64
 90 | /**
 91 |  * bswap_64 - reverse bytes in a uint64_t value.
 92 |  * @val: value whose bytes to swap.
 93 |  *
 94 |  * Example:
 95 |  *	// Output contains "1024 is 1125899906842624 as eight bytes reversed"
 96 |  *	printf("1024 is %llu as eight bytes reversed\n",
 97 |  *		(unsigned long long)bswap_64(1024));
 98 |  */
 99 | static inline uint64_t bswap_64(uint64_t val)
100 | {
101 | 	return BSWAP_64(val);
102 | }
103 | #endif
104 | 
105 | /* Needed for Glibc like endiness check */
106 | #define	__LITTLE_ENDIAN	1234
107 | #define	__BIG_ENDIAN	4321
108 | 
109 | /* Sanity check the defines.  We don't handle weird endianness. */
110 | #if HAVE_LITTLE_ENDIAN && HAVE_BIG_ENDIAN
111 | #error "Can't compile for both big and little endian."
112 | #elif HAVE_LITTLE_ENDIAN
113 | #ifndef __BYTE_ORDER
114 | #define __BYTE_ORDER	__LITTLE_ENDIAN
115 | #elif __BYTE_ORDER != __LITTLE_ENDIAN
116 | #error "__BYTE_ORDER already defined, but not equal to __LITTLE_ENDIAN"
117 | #endif
118 | #elif HAVE_BIG_ENDIAN
119 | #ifndef __BYTE_ORDER
120 | #define __BYTE_ORDER	__BIG_ENDIAN
121 | #elif __BYTE_ORDER != __BIG_ENDIAN
122 | #error "__BYTE_ORDER already defined, but not equal to __BIG_ENDIAN"
123 | #endif
124 | #endif
125 | 
126 | 
127 | #ifdef __CHECKER__
128 | /* sparse needs forcing to remove bitwise attribute from ccan/short_types */
129 | #define ENDIAN_CAST __attribute__((force))
130 | #define ENDIAN_TYPE __attribute__((bitwise))
131 | #else
132 | #define ENDIAN_CAST
133 | #define ENDIAN_TYPE
134 | #endif
135 | 
136 | typedef uint64_t ENDIAN_TYPE leint64_t;
137 | typedef uint64_t ENDIAN_TYPE beint64_t;
138 | typedef uint32_t ENDIAN_TYPE leint32_t;
139 | typedef uint32_t ENDIAN_TYPE beint32_t;
140 | typedef uint16_t ENDIAN_TYPE leint16_t;
141 | typedef uint16_t ENDIAN_TYPE beint16_t;
142 | 
143 | #if HAVE_LITTLE_ENDIAN
144 | /**
145 |  * CPU_TO_LE64 - convert a constant uint64_t value to little-endian
146 |  * @native: constant to convert
147 |  */
148 | #define CPU_TO_LE64(native) ((ENDIAN_CAST leint64_t)(native))
149 | 
150 | /**
151 |  * CPU_TO_LE32 - convert a constant uint32_t value to little-endian
152 |  * @native: constant to convert
153 |  */
154 | #define CPU_TO_LE32(native) ((ENDIAN_CAST leint32_t)(native))
155 | 
156 | /**
157 |  * CPU_TO_LE16 - convert a constant uint16_t value to little-endian
158 |  * @native: constant to convert
159 |  */
160 | #define CPU_TO_LE16(native) ((ENDIAN_CAST leint16_t)(native))
161 | 
162 | /**
163 |  * LE64_TO_CPU - convert a little-endian uint64_t constant
164 |  * @le_val: little-endian constant to convert
165 |  */
166 | #define LE64_TO_CPU(le_val) ((ENDIAN_CAST uint64_t)(le_val))
167 | 
168 | /**
169 |  * LE32_TO_CPU - convert a little-endian uint32_t constant
170 |  * @le_val: little-endian constant to convert
171 |  */
172 | #define LE32_TO_CPU(le_val) ((ENDIAN_CAST uint32_t)(le_val))
173 | 
174 | /**
175 |  * LE16_TO_CPU - convert a little-endian uint16_t constant
176 |  * @le_val: little-endian constant to convert
177 |  */
178 | #define LE16_TO_CPU(le_val) ((ENDIAN_CAST uint16_t)(le_val))
179 | 
180 | #else /* ... HAVE_BIG_ENDIAN */
181 | #define CPU_TO_LE64(native) ((ENDIAN_CAST leint64_t)BSWAP_64(native))
182 | #define CPU_TO_LE32(native) ((ENDIAN_CAST leint32_t)BSWAP_32(native))
183 | #define CPU_TO_LE16(native) ((ENDIAN_CAST leint16_t)BSWAP_16(native))
184 | #define LE64_TO_CPU(le_val) BSWAP_64((ENDIAN_CAST uint64_t)le_val)
185 | #define LE32_TO_CPU(le_val) BSWAP_32((ENDIAN_CAST uint32_t)le_val)
186 | #define LE16_TO_CPU(le_val) BSWAP_16((ENDIAN_CAST uint16_t)le_val)
187 | #endif /* HAVE_BIG_ENDIAN */
188 | 
189 | #if HAVE_BIG_ENDIAN
190 | /**
191 |  * CPU_TO_BE64 - convert a constant uint64_t value to big-endian
192 |  * @native: constant to convert
193 |  */
194 | #define CPU_TO_BE64(native) ((ENDIAN_CAST beint64_t)(native))
195 | 
196 | /**
197 |  * CPU_TO_BE32 - convert a constant uint32_t value to big-endian
198 |  * @native: constant to convert
199 |  */
200 | #define CPU_TO_BE32(native) ((ENDIAN_CAST beint32_t)(native))
201 | 
202 | /**
203 |  * CPU_TO_BE16 - convert a constant uint16_t value to big-endian
204 |  * @native: constant to convert
205 |  */
206 | #define CPU_TO_BE16(native) ((ENDIAN_CAST beint16_t)(native))
207 | 
208 | /**
209 |  * BE64_TO_CPU - convert a big-endian uint64_t constant
210 |  * @le_val: big-endian constant to convert
211 |  */
212 | #define BE64_TO_CPU(le_val) ((ENDIAN_CAST uint64_t)(le_val))
213 | 
214 | /**
215 |  * BE32_TO_CPU - convert a big-endian uint32_t constant
216 |  * @le_val: big-endian constant to convert
217 |  */
218 | #define BE32_TO_CPU(le_val) ((ENDIAN_CAST uint32_t)(le_val))
219 | 
220 | /**
221 |  * BE16_TO_CPU - convert a big-endian uint16_t constant
222 |  * @le_val: big-endian constant to convert
223 |  */
224 | #define BE16_TO_CPU(le_val) ((ENDIAN_CAST uint16_t)(le_val))
225 | 
226 | #else /* ... HAVE_LITTLE_ENDIAN */
227 | #define CPU_TO_BE64(native) ((ENDIAN_CAST beint64_t)BSWAP_64(native))
228 | #define CPU_TO_BE32(native) ((ENDIAN_CAST beint32_t)BSWAP_32(native))
229 | #define CPU_TO_BE16(native) ((ENDIAN_CAST beint16_t)BSWAP_16(native))
230 | #define BE64_TO_CPU(le_val) BSWAP_64((ENDIAN_CAST uint64_t)le_val)
231 | #define BE32_TO_CPU(le_val) BSWAP_32((ENDIAN_CAST uint32_t)le_val)
232 | #define BE16_TO_CPU(le_val) BSWAP_16((ENDIAN_CAST uint16_t)le_val)
233 | #endif /* HAVE_LITTE_ENDIAN */
234 | 
235 | 
236 | /**
237 |  * cpu_to_le64 - convert a uint64_t value to little-endian
238 |  * @native: value to convert
239 |  */
240 | static inline leint64_t cpu_to_le64(uint64_t native)
241 | {
242 | 	return CPU_TO_LE64(native);
243 | }
244 | 
245 | /**
246 |  * cpu_to_le32 - convert a uint32_t value to little-endian
247 |  * @native: value to convert
248 |  */
249 | static inline leint32_t cpu_to_le32(uint32_t native)
250 | {
251 | 	return CPU_TO_LE32(native);
252 | }
253 | 
254 | /**
255 |  * cpu_to_le16 - convert a uint16_t value to little-endian
256 |  * @native: value to convert
257 |  */
258 | static inline leint16_t cpu_to_le16(uint16_t native)
259 | {
260 | 	return CPU_TO_LE16(native);
261 | }
262 | 
263 | /**
264 |  * le64_to_cpu - convert a little-endian uint64_t value
265 |  * @le_val: little-endian value to convert
266 |  */
267 | static inline uint64_t le64_to_cpu(leint64_t le_val)
268 | {
269 | 	return LE64_TO_CPU(le_val);
270 | }
271 | 
272 | /**
273 |  * le32_to_cpu - convert a little-endian uint32_t value
274 |  * @le_val: little-endian value to convert
275 |  */
276 | static inline uint32_t le32_to_cpu(leint32_t le_val)
277 | {
278 | 	return LE32_TO_CPU(le_val);
279 | }
280 | 
281 | /**
282 |  * le16_to_cpu - convert a little-endian uint16_t value
283 |  * @le_val: little-endian value to convert
284 |  */
285 | static inline uint16_t le16_to_cpu(leint16_t le_val)
286 | {
287 | 	return LE16_TO_CPU(le_val);
288 | }
289 | 
290 | /**
291 |  * cpu_to_be64 - convert a uint64_t value to big endian.
292 |  * @native: value to convert
293 |  */
294 | static inline beint64_t cpu_to_be64(uint64_t native)
295 | {
296 | 	return CPU_TO_BE64(native);
297 | }
298 | 
299 | /**
300 |  * cpu_to_be32 - convert a uint32_t value to big endian.
301 |  * @native: value to convert
302 |  */
303 | static inline beint32_t cpu_to_be32(uint32_t native)
304 | {
305 | 	return CPU_TO_BE32(native);
306 | }
307 | 
308 | /**
309 |  * cpu_to_be16 - convert a uint16_t value to big endian.
310 |  * @native: value to convert
311 |  */
312 | static inline beint16_t cpu_to_be16(uint16_t native)
313 | {
314 | 	return CPU_TO_BE16(native);
315 | }
316 | 
317 | /**
318 |  * be64_to_cpu - convert a big-endian uint64_t value
319 |  * @be_val: big-endian value to convert
320 |  */
321 | static inline uint64_t be64_to_cpu(beint64_t be_val)
322 | {
323 | 	return BE64_TO_CPU(be_val);
324 | }
325 | 
326 | /**
327 |  * be32_to_cpu - convert a big-endian uint32_t value
328 |  * @be_val: big-endian value to convert
329 |  */
330 | static inline uint32_t be32_to_cpu(beint32_t be_val)
331 | {
332 | 	return BE32_TO_CPU(be_val);
333 | }
334 | 
335 | /**
336 |  * be16_to_cpu - convert a big-endian uint16_t value
337 |  * @be_val: big-endian value to convert
338 |  */
339 | static inline uint16_t be16_to_cpu(beint16_t be_val)
340 | {
341 | 	return BE16_TO_CPU(be_val);
342 | }
343 | 
344 | /* Whichever they include first, they get these definitions. */
345 | #ifdef CCAN_SHORT_TYPES_H
346 | /**
347 |  * be64/be32/be16 - 64/32/16 bit big-endian representation.
348 |  */
349 | typedef beint64_t be64;
350 | typedef beint32_t be32;
351 | typedef beint16_t be16;
352 | 
353 | /**
354 |  * le64/le32/le16 - 64/32/16 bit little-endian representation.
355 |  */
356 | typedef leint64_t le64;
357 | typedef leint32_t le32;
358 | typedef leint16_t le16;
359 | #endif
360 | #endif /* CCAN_ENDIAN_H */
361 | 


--------------------------------------------------------------------------------
/sha256.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /* MIT (BSD) license - see LICENSE file for details */
  3 | /* SHA256 core code translated from the Bitcoin project's C++:
  4 |  *
  5 |  * src/crypto/sha256.cpp commit 417532c8acb93c36c2b6fd052b7c11b6a2906aa2
  6 |  * Copyright (c) 2014 The Bitcoin Core developers
  7 |  * Distributed under the MIT software license, see the accompanying
  8 |  * file COPYING or http://www.opensource.org/licenses/mit-license.php.
  9 |  */
 10 | #include "sha256.h"
 11 | #include "endian.h"
 12 | #include "compiler.h"
 13 | #include <stdbool.h>
 14 | #include <assert.h>
 15 | #include <string.h>
 16 | 
 17 | static void invalidate_sha256(struct sha256_ctx *ctx)
 18 | {
 19 | #ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
 20 | 	ctx->c.md_len = 0;
 21 | #else
 22 | 	ctx->bytes = (size_t)-1;
 23 | #endif
 24 | }
 25 | 
 26 | static void check_sha256(struct sha256_ctx *ctx)
 27 | {
 28 | #ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
 29 | 	assert(ctx->c.md_len != 0);
 30 | #else
 31 | 	assert(ctx->bytes != (size_t)-1);
 32 | #endif
 33 | }
 34 | 
 35 | #ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
 36 | void sha256_init(struct sha256_ctx *ctx)
 37 | {
 38 | 	SHA256_Init(&ctx->c);
 39 | }
 40 | 
 41 | void sha256_update(struct sha256_ctx *ctx, const void *p, size_t size)
 42 | {
 43 | 	check_sha256(ctx);
 44 | 	SHA256_Update(&ctx->c, p, size);
 45 | }
 46 | 
 47 | void sha256_done(struct sha256_ctx *ctx, struct sha256 *res)
 48 | {
 49 | 	SHA256_Final(res->u.u8, &ctx->c);
 50 | 	invalidate_sha256(ctx);
 51 | }
 52 | #else
 53 | static uint32_t Ch(uint32_t x, uint32_t y, uint32_t z)
 54 | {
 55 | 	return z ^ (x & (y ^ z));
 56 | }
 57 | static uint32_t Maj(uint32_t x, uint32_t y, uint32_t z)
 58 | {
 59 | 	return (x & y) | (z & (x | y));
 60 | }
 61 | static uint32_t Sigma0(uint32_t x)
 62 | {
 63 | 	return (x >> 2 | x << 30) ^ (x >> 13 | x << 19) ^ (x >> 22 | x << 10);
 64 | }
 65 | static uint32_t Sigma1(uint32_t x)
 66 | {
 67 | 	return (x >> 6 | x << 26) ^ (x >> 11 | x << 21) ^ (x >> 25 | x << 7);
 68 | }
 69 | static uint32_t sigma0(uint32_t x)
 70 | {
 71 | 	return (x >> 7 | x << 25) ^ (x >> 18 | x << 14) ^ (x >> 3);
 72 | }
 73 | static uint32_t sigma1(uint32_t x)
 74 | {
 75 | 	return (x >> 17 | x << 15) ^ (x >> 19 | x << 13) ^ (x >> 10);
 76 | }
 77 | 
 78 | /** One round of SHA-256. */
 79 | static void Round(uint32_t a, uint32_t b, uint32_t c, uint32_t *d, uint32_t e, uint32_t f, uint32_t g, uint32_t *h, uint32_t k, uint32_t w)
 80 | {
 81 | 	uint32_t t1 = *h + Sigma1(e) + Ch(e, f, g) + k + w;
 82 | 	uint32_t t2 = Sigma0(a) + Maj(a, b, c);
 83 | 	*d += t1;
 84 | 	*h = t1 + t2;
 85 | }
 86 | 
 87 | /** Perform one SHA-256 transformation, processing a 64-byte chunk. */
 88 | static void Transform(uint32_t *s, const uint32_t *chunk)
 89 | {
 90 | 	uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
 91 | 	uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
 92 | 
 93 | 	Round(a, b, c, &d, e, f, g, &h, 0x428a2f98, w0 = be32_to_cpu(chunk[0]));
 94 | 	Round(h, a, b, &c, d, e, f, &g, 0x71374491, w1 = be32_to_cpu(chunk[1]));
 95 | 	Round(g, h, a, &b, c, d, e, &f, 0xb5c0fbcf, w2 = be32_to_cpu(chunk[2]));
 96 | 	Round(f, g, h, &a, b, c, d, &e, 0xe9b5dba5, w3 = be32_to_cpu(chunk[3]));
 97 | 	Round(e, f, g, &h, a, b, c, &d, 0x3956c25b, w4 = be32_to_cpu(chunk[4]));
 98 | 	Round(d, e, f, &g, h, a, b, &c, 0x59f111f1, w5 = be32_to_cpu(chunk[5]));
 99 | 	Round(c, d, e, &f, g, h, a, &b, 0x923f82a4, w6 = be32_to_cpu(chunk[6]));
100 | 	Round(b, c, d, &e, f, g, h, &a, 0xab1c5ed5, w7 = be32_to_cpu(chunk[7]));
101 | 	Round(a, b, c, &d, e, f, g, &h, 0xd807aa98, w8 = be32_to_cpu(chunk[8]));
102 | 	Round(h, a, b, &c, d, e, f, &g, 0x12835b01, w9 = be32_to_cpu(chunk[9]));
103 | 	Round(g, h, a, &b, c, d, e, &f, 0x243185be, w10 = be32_to_cpu(chunk[10]));
104 | 	Round(f, g, h, &a, b, c, d, &e, 0x550c7dc3, w11 = be32_to_cpu(chunk[11]));
105 | 	Round(e, f, g, &h, a, b, c, &d, 0x72be5d74, w12 = be32_to_cpu(chunk[12]));
106 | 	Round(d, e, f, &g, h, a, b, &c, 0x80deb1fe, w13 = be32_to_cpu(chunk[13]));
107 | 	Round(c, d, e, &f, g, h, a, &b, 0x9bdc06a7, w14 = be32_to_cpu(chunk[14]));
108 | 	Round(b, c, d, &e, f, g, h, &a, 0xc19bf174, w15 = be32_to_cpu(chunk[15]));
109 | 
110 | 	Round(a, b, c, &d, e, f, g, &h, 0xe49b69c1, w0 += sigma1(w14) + w9 + sigma0(w1));
111 | 	Round(h, a, b, &c, d, e, f, &g, 0xefbe4786, w1 += sigma1(w15) + w10 + sigma0(w2));
112 | 	Round(g, h, a, &b, c, d, e, &f, 0x0fc19dc6, w2 += sigma1(w0) + w11 + sigma0(w3));
113 | 	Round(f, g, h, &a, b, c, d, &e, 0x240ca1cc, w3 += sigma1(w1) + w12 + sigma0(w4));
114 | 	Round(e, f, g, &h, a, b, c, &d, 0x2de92c6f, w4 += sigma1(w2) + w13 + sigma0(w5));
115 | 	Round(d, e, f, &g, h, a, b, &c, 0x4a7484aa, w5 += sigma1(w3) + w14 + sigma0(w6));
116 | 	Round(c, d, e, &f, g, h, a, &b, 0x5cb0a9dc, w6 += sigma1(w4) + w15 + sigma0(w7));
117 | 	Round(b, c, d, &e, f, g, h, &a, 0x76f988da, w7 += sigma1(w5) + w0 + sigma0(w8));
118 | 	Round(a, b, c, &d, e, f, g, &h, 0x983e5152, w8 += sigma1(w6) + w1 + sigma0(w9));
119 | 	Round(h, a, b, &c, d, e, f, &g, 0xa831c66d, w9 += sigma1(w7) + w2 + sigma0(w10));
120 | 	Round(g, h, a, &b, c, d, e, &f, 0xb00327c8, w10 += sigma1(w8) + w3 + sigma0(w11));
121 | 	Round(f, g, h, &a, b, c, d, &e, 0xbf597fc7, w11 += sigma1(w9) + w4 + sigma0(w12));
122 | 	Round(e, f, g, &h, a, b, c, &d, 0xc6e00bf3, w12 += sigma1(w10) + w5 + sigma0(w13));
123 | 	Round(d, e, f, &g, h, a, b, &c, 0xd5a79147, w13 += sigma1(w11) + w6 + sigma0(w14));
124 | 	Round(c, d, e, &f, g, h, a, &b, 0x06ca6351, w14 += sigma1(w12) + w7 + sigma0(w15));
125 | 	Round(b, c, d, &e, f, g, h, &a, 0x14292967, w15 += sigma1(w13) + w8 + sigma0(w0));
126 | 
127 | 	Round(a, b, c, &d, e, f, g, &h, 0x27b70a85, w0 += sigma1(w14) + w9 + sigma0(w1));
128 | 	Round(h, a, b, &c, d, e, f, &g, 0x2e1b2138, w1 += sigma1(w15) + w10 + sigma0(w2));
129 | 	Round(g, h, a, &b, c, d, e, &f, 0x4d2c6dfc, w2 += sigma1(w0) + w11 + sigma0(w3));
130 | 	Round(f, g, h, &a, b, c, d, &e, 0x53380d13, w3 += sigma1(w1) + w12 + sigma0(w4));
131 | 	Round(e, f, g, &h, a, b, c, &d, 0x650a7354, w4 += sigma1(w2) + w13 + sigma0(w5));
132 | 	Round(d, e, f, &g, h, a, b, &c, 0x766a0abb, w5 += sigma1(w3) + w14 + sigma0(w6));
133 | 	Round(c, d, e, &f, g, h, a, &b, 0x81c2c92e, w6 += sigma1(w4) + w15 + sigma0(w7));
134 | 	Round(b, c, d, &e, f, g, h, &a, 0x92722c85, w7 += sigma1(w5) + w0 + sigma0(w8));
135 | 	Round(a, b, c, &d, e, f, g, &h, 0xa2bfe8a1, w8 += sigma1(w6) + w1 + sigma0(w9));
136 | 	Round(h, a, b, &c, d, e, f, &g, 0xa81a664b, w9 += sigma1(w7) + w2 + sigma0(w10));
137 | 	Round(g, h, a, &b, c, d, e, &f, 0xc24b8b70, w10 += sigma1(w8) + w3 + sigma0(w11));
138 | 	Round(f, g, h, &a, b, c, d, &e, 0xc76c51a3, w11 += sigma1(w9) + w4 + sigma0(w12));
139 | 	Round(e, f, g, &h, a, b, c, &d, 0xd192e819, w12 += sigma1(w10) + w5 + sigma0(w13));
140 | 	Round(d, e, f, &g, h, a, b, &c, 0xd6990624, w13 += sigma1(w11) + w6 + sigma0(w14));
141 | 	Round(c, d, e, &f, g, h, a, &b, 0xf40e3585, w14 += sigma1(w12) + w7 + sigma0(w15));
142 | 	Round(b, c, d, &e, f, g, h, &a, 0x106aa070, w15 += sigma1(w13) + w8 + sigma0(w0));
143 | 
144 | 	Round(a, b, c, &d, e, f, g, &h, 0x19a4c116, w0 += sigma1(w14) + w9 + sigma0(w1));
145 | 	Round(h, a, b, &c, d, e, f, &g, 0x1e376c08, w1 += sigma1(w15) + w10 + sigma0(w2));
146 | 	Round(g, h, a, &b, c, d, e, &f, 0x2748774c, w2 += sigma1(w0) + w11 + sigma0(w3));
147 | 	Round(f, g, h, &a, b, c, d, &e, 0x34b0bcb5, w3 += sigma1(w1) + w12 + sigma0(w4));
148 | 	Round(e, f, g, &h, a, b, c, &d, 0x391c0cb3, w4 += sigma1(w2) + w13 + sigma0(w5));
149 | 	Round(d, e, f, &g, h, a, b, &c, 0x4ed8aa4a, w5 += sigma1(w3) + w14 + sigma0(w6));
150 | 	Round(c, d, e, &f, g, h, a, &b, 0x5b9cca4f, w6 += sigma1(w4) + w15 + sigma0(w7));
151 | 	Round(b, c, d, &e, f, g, h, &a, 0x682e6ff3, w7 += sigma1(w5) + w0 + sigma0(w8));
152 | 	Round(a, b, c, &d, e, f, g, &h, 0x748f82ee, w8 += sigma1(w6) + w1 + sigma0(w9));
153 | 	Round(h, a, b, &c, d, e, f, &g, 0x78a5636f, w9 += sigma1(w7) + w2 + sigma0(w10));
154 | 	Round(g, h, a, &b, c, d, e, &f, 0x84c87814, w10 += sigma1(w8) + w3 + sigma0(w11));
155 | 	Round(f, g, h, &a, b, c, d, &e, 0x8cc70208, w11 += sigma1(w9) + w4 + sigma0(w12));
156 | 	Round(e, f, g, &h, a, b, c, &d, 0x90befffa, w12 += sigma1(w10) + w5 + sigma0(w13));
157 | 	Round(d, e, f, &g, h, a, b, &c, 0xa4506ceb, w13 += sigma1(w11) + w6 + sigma0(w14));
158 | 	Round(c, d, e, &f, g, h, a, &b, 0xbef9a3f7, w14 + sigma1(w12) + w7 + sigma0(w15));
159 | 	Round(b, c, d, &e, f, g, h, &a, 0xc67178f2, w15 + sigma1(w13) + w8 + sigma0(w0));
160 | 
161 | 	s[0] += a;
162 | 	s[1] += b;
163 | 	s[2] += c;
164 | 	s[3] += d;
165 | 	s[4] += e;
166 | 	s[5] += f;
167 | 	s[6] += g;
168 | 	s[7] += h;
169 | }
170 | 
171 | 
172 | static void add(struct sha256_ctx *ctx, const void *p, size_t len)
173 | {
174 | 	const unsigned char *data = p;
175 | 	size_t bufsize = ctx->bytes % 64;
176 | 
177 | 	if (bufsize + len >= 64) {
178 | 		/* Fill the buffer, and process it. */
179 | 		memcpy(ctx->buf.u8 + bufsize, data, 64 - bufsize);
180 | 		ctx->bytes += 64 - bufsize;
181 | 		data += 64 - bufsize;
182 | 		len -= 64 - bufsize;
183 | 		Transform(ctx->s, ctx->buf.u32);
184 | 		bufsize = 0;
185 | 	}
186 | 
187 | 	while (len >= 64) {
188 | 		/* Process full chunks directly from the source. */
189 | 		if (alignment_ok(data, sizeof(uint32_t)))
190 | 			Transform(ctx->s, (const uint32_t *)data);
191 | 		else {
192 | 			memcpy(ctx->buf.u8, data, sizeof(ctx->buf));
193 | 			Transform(ctx->s, ctx->buf.u32);
194 | 		}
195 | 		ctx->bytes += 64;
196 | 		data += 64;
197 | 		len -= 64;
198 | 	}
199 | 
200 | 	if (len) {
201 | 		/* Fill the buffer with what remains. */
202 | 		memcpy(ctx->buf.u8 + bufsize, data, len);
203 | 		ctx->bytes += len;
204 | 	}
205 | }
206 | 
207 | void sha256_init(struct sha256_ctx *ctx)
208 | {
209 | 	struct sha256_ctx init = SHA256_INIT;
210 | 	*ctx = init;
211 | }
212 | 
213 | void sha256_update(struct sha256_ctx *ctx, const void *p, size_t size)
214 | {
215 | 	check_sha256(ctx);
216 | 	add(ctx, p, size);
217 | }
218 | 
219 | void sha256_done(struct sha256_ctx *ctx, struct sha256 *res)
220 | {
221 | 	static const unsigned char pad[64] = {0x80};
222 | 	uint64_t sizedesc;
223 | 	size_t i;
224 | 
225 | 	sizedesc = cpu_to_be64((uint64_t)ctx->bytes << 3);
226 | 	/* Add '1' bit to terminate, then all 0 bits, up to next block - 8. */
227 | 	add(ctx, pad, 1 + ((128 - 8 - (ctx->bytes % 64) - 1) % 64));
228 | 	/* Add number of bits of data (big endian) */
229 | 	add(ctx, &sizedesc, 8);
230 | 	for (i = 0; i < sizeof(ctx->s) / sizeof(ctx->s[0]); i++)
231 | 		res->u.u32[i] = cpu_to_be32(ctx->s[i]);
232 | 	invalidate_sha256(ctx);
233 | }
234 | #endif
235 | 
236 | void sha256(struct sha256 *sha, const void *p, size_t size)
237 | {
238 | 	struct sha256_ctx ctx;
239 | 
240 | 	sha256_init(&ctx);
241 | 	sha256_update(&ctx, p, size);
242 | 	sha256_done(&ctx, sha);
243 | }
244 | 
245 | void sha256_u8(struct sha256_ctx *ctx, uint8_t v)
246 | {
247 | 	sha256_update(ctx, &v, sizeof(v));
248 | }
249 | 
250 | void sha256_u16(struct sha256_ctx *ctx, uint16_t v)
251 | {
252 | 	sha256_update(ctx, &v, sizeof(v));
253 | }
254 | 
255 | void sha256_u32(struct sha256_ctx *ctx, uint32_t v)
256 | {
257 | 	sha256_update(ctx, &v, sizeof(v));
258 | }
259 | 
260 | void sha256_u64(struct sha256_ctx *ctx, uint64_t v)
261 | {
262 | 	sha256_update(ctx, &v, sizeof(v));
263 | }
264 | 
265 | /* Add as little-endian */
266 | void sha256_le16(struct sha256_ctx *ctx, uint16_t v)
267 | {
268 | 	leint16_t lev = cpu_to_le16(v);
269 | 	sha256_update(ctx, &lev, sizeof(lev));
270 | }
271 | 
272 | void sha256_le32(struct sha256_ctx *ctx, uint32_t v)
273 | {
274 | 	leint32_t lev = cpu_to_le32(v);
275 | 	sha256_update(ctx, &lev, sizeof(lev));
276 | }
277 | 
278 | void sha256_le64(struct sha256_ctx *ctx, uint64_t v)
279 | {
280 | 	leint64_t lev = cpu_to_le64(v);
281 | 	sha256_update(ctx, &lev, sizeof(lev));
282 | }
283 | 
284 | /* Add as big-endian */
285 | void sha256_be16(struct sha256_ctx *ctx, uint16_t v)
286 | {
287 | 	beint16_t bev = cpu_to_be16(v);
288 | 	sha256_update(ctx, &bev, sizeof(bev));
289 | }
290 | 
291 | void sha256_be32(struct sha256_ctx *ctx, uint32_t v)
292 | {
293 | 	beint32_t bev = cpu_to_be32(v);
294 | 	sha256_update(ctx, &bev, sizeof(bev));
295 | }
296 | 
297 | void sha256_be64(struct sha256_ctx *ctx, uint64_t v)
298 | {
299 | 	beint64_t bev = cpu_to_be64(v);
300 | 	sha256_update(ctx, &bev, sizeof(bev));
301 | }
302 | 
303 | 
304 | int sha256d(const unsigned char *bytes, size_t bytes_len,
305 |                   unsigned char *bytes_out, size_t len)
306 | {
307 | 	struct sha256 sha_1, sha_2;
308 | 	bool aligned = alignment_ok(bytes_out, sizeof(sha_1.u.u32));
309 | 
310 | 	if (!bytes || !bytes_out || len != SHA256_LEN)
311 | 		return 0;
312 | 
313 | 	sha256(&sha_1, bytes, bytes_len);
314 | 	sha256(aligned ? (struct sha256 *)bytes_out : &sha_2, &sha_1, sizeof(sha_1));
315 | 	if (!aligned) {
316 | 		memcpy(bytes_out, &sha_2, sizeof(sha_2));
317 | 		wally_clear(&sha_2, sizeof(sha_2));
318 | 	}
319 | 	wally_clear(&sha_1, sizeof(sha_1));
320 | 	return 1;
321 | }
322 | 


--------------------------------------------------------------------------------
/op.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "script.h"
  3 | #include "oplookup.h"
  4 | #include "op.h"
  5 | #include "alloc.h"
  6 | #include "misc.h"
  7 | 
  8 | #include <inttypes.h>
  9 | #include <stdio.h>
 10 | #include <string.h>
 11 | #include <ctype.h>
 12 | 
 13 | 
 14 | 
 15 | static enum opcode
 16 | op_from_token(enum opcode_token opcode) {
 17 | 	switch (opcode) {
 18 | 	case _OP_0: return OP_0;
 19 | 	case _OP_FALSE: return OP_FALSE;
 20 | 	case _OP_PUSHDATA1: return OP_PUSHDATA1;
 21 | 	case _OP_PUSHDATA2: return OP_PUSHDATA2;
 22 | 	case _OP_PUSHDATA4: return OP_PUSHDATA4;
 23 | 	case _OP_1NEGATE: return OP_1NEGATE;
 24 | 	case _OP_RESERVED: return OP_RESERVED;
 25 | 	case _OP_1: return OP_1;
 26 | 	case _OP_TRUE: return OP_TRUE;
 27 | 	case _OP_2: return OP_2;
 28 | 	case _OP_3: return OP_3;
 29 | 	case _OP_4: return OP_4;
 30 | 	case _OP_5: return OP_5;
 31 | 	case _OP_6: return OP_6;
 32 | 	case _OP_7: return OP_7;
 33 | 	case _OP_8: return OP_8;
 34 | 	case _OP_9: return OP_9;
 35 | 	case _OP_10: return OP_10;
 36 | 	case _OP_11: return OP_11;
 37 | 	case _OP_12: return OP_12;
 38 | 	case _OP_13: return OP_13;
 39 | 	case _OP_14: return OP_14;
 40 | 	case _OP_15: return OP_15;
 41 | 	case _OP_16: return OP_16;
 42 | 	case _OP_NOP: return OP_NOP;
 43 | 	case _OP_VER: return OP_VER;
 44 | 	case _OP_IF: return OP_IF;
 45 | 	case _OP_NOTIF: return OP_NOTIF;
 46 | 	case _OP_VERIF: return OP_VERIF;
 47 | 	case _OP_VERNOTIF: return OP_VERNOTIF;
 48 | 	case _OP_ELSE: return OP_ELSE;
 49 | 	case _OP_ENDIF: return OP_ENDIF;
 50 | 	case _OP_VERIFY: return OP_VERIFY;
 51 | 	case _OP_RETURN: return OP_RETURN;
 52 | 	case _OP_TOALTSTACK: return OP_TOALTSTACK;
 53 | 	case _OP_FROMALTSTACK: return OP_FROMALTSTACK;
 54 | 	case _OP_2DROP: return OP_2DROP;
 55 | 	case _OP_2DUP: return OP_2DUP;
 56 | 	case _OP_3DUP: return OP_3DUP;
 57 | 	case _OP_2OVER: return OP_2OVER;
 58 | 	case _OP_2ROT: return OP_2ROT;
 59 | 	case _OP_2SWAP: return OP_2SWAP;
 60 | 	case _OP_IFDUP: return OP_IFDUP;
 61 | 	case _OP_DEPTH: return OP_DEPTH;
 62 | 	case _OP_DROP: return OP_DROP;
 63 | 	case _OP_DUP: return OP_DUP;
 64 | 	case _OP_NIP: return OP_NIP;
 65 | 	case _OP_OVER: return OP_OVER;
 66 | 	case _OP_PICK: return OP_PICK;
 67 | 	case _OP_ROLL: return OP_ROLL;
 68 | 	case _OP_ROT: return OP_ROT;
 69 | 	case _OP_SWAP: return OP_SWAP;
 70 | 	case _OP_TUCK: return OP_TUCK;
 71 | 	case _OP_CAT: return OP_CAT;
 72 | 	case _OP_SUBSTR: return OP_SUBSTR;
 73 | 	case _OP_LEFT: return OP_LEFT;
 74 | 	case _OP_RIGHT: return OP_RIGHT;
 75 | 	case _OP_SIZE: return OP_SIZE;
 76 | 	case _OP_INVERT: return OP_INVERT;
 77 | 	case _OP_AND: return OP_AND;
 78 | 	case _OP_OR: return OP_OR;
 79 | 	case _OP_XOR: return OP_XOR;
 80 | 	case _OP_EQUAL: return OP_EQUAL;
 81 | 	case _OP_EQUALVERIFY: return OP_EQUALVERIFY;
 82 | 	case _OP_RESERVED1: return OP_RESERVED1;
 83 | 	case _OP_RESERVED2: return OP_RESERVED2;
 84 | 	case _OP_1ADD: return OP_1ADD;
 85 | 	case _OP_1SUB: return OP_1SUB;
 86 | 	case _OP_2MUL: return OP_2MUL;
 87 | 	case _OP_2DIV: return OP_2DIV;
 88 | 	case _OP_NEGATE: return OP_NEGATE;
 89 | 	case _OP_ABS: return OP_ABS;
 90 | 	case _OP_NOT: return OP_NOT;
 91 | 	case _OP_0NOTEQUAL: return OP_0NOTEQUAL;
 92 | 	case _OP_ADD: return OP_ADD;
 93 | 	case _OP_SUB: return OP_SUB;
 94 | 	case _OP_MUL: return OP_MUL;
 95 | 	case _OP_DIV: return OP_DIV;
 96 | 	case _OP_MOD: return OP_MOD;
 97 | 	case _OP_LSHIFT: return OP_LSHIFT;
 98 | 	case _OP_RSHIFT: return OP_RSHIFT;
 99 | 	case _OP_BOOLAND: return OP_BOOLAND;
100 | 	case _OP_BOOLOR: return OP_BOOLOR;
101 | 	case _OP_NUMEQUAL: return OP_NUMEQUAL;
102 | 	case _OP_NUMEQUALVERIFY: return OP_NUMEQUALVERIFY;
103 | 	case _OP_NUMNOTEQUAL: return OP_NUMNOTEQUAL;
104 | 	case _OP_LESSTHAN: return OP_LESSTHAN;
105 | 	case _OP_GREATERTHAN: return OP_GREATERTHAN;
106 | 	case _OP_LESSTHANOREQUAL: return OP_LESSTHANOREQUAL;
107 | 	case _OP_GREATERTHANOREQUAL: return OP_GREATERTHANOREQUAL;
108 | 	case _OP_MIN: return OP_MIN;
109 | 	case _OP_MAX: return OP_MAX;
110 | 	case _OP_WITHIN: return OP_WITHIN;
111 | 	case _OP_RIPEMD160: return OP_RIPEMD160;
112 | 	case _OP_SHA1: return OP_SHA1;
113 | 	case _OP_SHA256: return OP_SHA256;
114 | 	case _OP_HASH160: return OP_HASH160;
115 | 	case _OP_HASH256: return OP_HASH256;
116 | 	case _OP_CODESEPARATOR: return OP_CODESEPARATOR;
117 | 	case _OP_CHECKSIG: return OP_CHECKSIG;
118 | 	case _OP_CHECKSIGVERIFY: return OP_CHECKSIGVERIFY;
119 | 	case _OP_CHECKMULTISIG: return OP_CHECKMULTISIG;
120 | 	case _OP_CHECKMULTISIGVERIFY: return OP_CHECKMULTISIGVERIFY;
121 | 	case _OP_NOP1: return OP_NOP1;
122 | 	case _OP_CHECKLOCKTIMEVERIFY: return OP_CHECKLOCKTIMEVERIFY;
123 | 	case _OP_NOP2: return OP_NOP2;
124 | 	case _OP_CHECKSEQUENCEVERIFY: return OP_CHECKSEQUENCEVERIFY;
125 | 	case _OP_NOP3: return OP_NOP3;
126 | 	case _OP_NOP4: return OP_NOP4;
127 | 	case _OP_NOP5: return OP_NOP5;
128 | 	case _OP_NOP6: return OP_NOP6;
129 | 	case _OP_NOP7: return OP_NOP7;
130 | 	case _OP_NOP8: return OP_NOP8;
131 | 	case _OP_NOP9: return OP_NOP9;
132 | 	case _OP_NOP10: return OP_NOP10;
133 | 	case _OP_SMALLINTEGER: return OP_SMALLINTEGER;
134 | 	case _OP_PUBKEYS: return OP_PUBKEYS;
135 | 	case _OP_PUBKEYHASH: return OP_PUBKEYHASH;
136 | 	case _OP_PUBKEY: return OP_PUBKEY;
137 | 	case _OP_INVALIDOPCODE: return OP_INVALIDOPCODE;
138 | 	}
139 | 	
140 | 	return OP_INVALIDOPCODE;
141 | }
142 | 
143 | const char*
144 | op_name(enum opcode opcode)
145 | {
146 | 	switch (opcode)
147 | 	{
148 | 	// push value
149 | 	case OP_0                      : return "0";
150 | 	case OP_PUSHDATA1              : return "PUSHDATA1";
151 | 	case OP_PUSHDATA2              : return "PUSHDATA2";
152 | 	case OP_PUSHDATA4              : return "PUSHDATA4";
153 | 	case OP_1NEGATE                : return "-1";
154 | 	case OP_RESERVED               : return "RESERVED";
155 | 	case OP_1                      : return "1";
156 | 	case OP_2                      : return "2";
157 | 	case OP_3                      : return "3";
158 | 	case OP_4                      : return "4";
159 | 	case OP_5                      : return "5";
160 | 	case OP_6                      : return "6";
161 | 	case OP_7                      : return "7";
162 | 	case OP_8                      : return "8";
163 | 	case OP_9                      : return "9";
164 | 	case OP_10                     : return "10";
165 | 	case OP_11                     : return "11";
166 | 	case OP_12                     : return "12";
167 | 	case OP_13                     : return "13";
168 | 	case OP_14                     : return "14";
169 | 	case OP_15                     : return "15";
170 | 	case OP_16                     : return "16";
171 | 	
172 | 	// control
173 | 	case OP_NOP                    : return "NOP";
174 | 	case OP_VER                    : return "VER";
175 | 	case OP_IF                     : return "IF";
176 | 	case OP_NOTIF                  : return "NOTIF";
177 | 	case OP_VERIF                  : return "VERIF";
178 | 	case OP_VERNOTIF               : return "VERNOTIF";
179 | 	case OP_ELSE                   : return "ELSE";
180 | 	case OP_ENDIF                  : return "ENDIF";
181 | 	case OP_VERIFY                 : return "VERIFY";
182 | 	case OP_RETURN                 : return "RETURN";
183 | 	
184 | 	// stack ops
185 | 	case OP_TOALTSTACK             : return "TOALTSTACK";
186 | 	case OP_FROMALTSTACK           : return "FROMALTSTACK";
187 | 	case OP_2DROP                  : return "2DROP";
188 | 	case OP_2DUP                   : return "2DUP";
189 | 	case OP_3DUP                   : return "3DUP";
190 | 	case OP_2OVER                  : return "2OVER";
191 | 	case OP_2ROT                   : return "2ROT";
192 | 	case OP_2SWAP                  : return "2SWAP";
193 | 	case OP_IFDUP                  : return "IFDUP";
194 | 	case OP_DEPTH                  : return "DEPTH";
195 | 	case OP_DROP                   : return "DROP";
196 | 	case OP_DUP                    : return "DUP";
197 | 	case OP_NIP                    : return "NIP";
198 | 	case OP_OVER                   : return "OVER";
199 | 	case OP_PICK                   : return "PICK";
200 | 	case OP_ROLL                   : return "ROLL";
201 | 	case OP_ROT                    : return "ROT";
202 | 	case OP_SWAP                   : return "SWAP";
203 | 	case OP_TUCK                   : return "TUCK";
204 | 	
205 | 	// splice ops
206 | 	case OP_CAT                    : return "CAT";
207 | 	case OP_SUBSTR                 : return "SUBSTR";
208 | 	case OP_LEFT                   : return "LEFT";
209 | 	case OP_RIGHT                  : return "RIGHT";
210 | 	case OP_SIZE                   : return "SIZE";
211 | 	
212 | 	// bit logic
213 | 	case OP_INVERT                 : return "INVERT";
214 | 	case OP_AND                    : return "AND";
215 | 	case OP_OR                     : return "OR";
216 | 	case OP_XOR                    : return "XOR";
217 | 	case OP_EQUAL                  : return "EQUAL";
218 | 	case OP_EQUALVERIFY            : return "EQUALVERIFY";
219 | 	case OP_RESERVED1              : return "RESERVED1";
220 | 	case OP_RESERVED2              : return "RESERVED2";
221 | 	
222 | 	// numeric
223 | 	case OP_1ADD                   : return "1ADD";
224 | 	case OP_1SUB                   : return "1SUB";
225 | 	case OP_2MUL                   : return "2MUL";
226 | 	case OP_2DIV                   : return "2DIV";
227 | 	case OP_NEGATE                 : return "NEGATE";
228 | 	case OP_ABS                    : return "ABS";
229 | 	case OP_NOT                    : return "NOT";
230 | 	case OP_0NOTEQUAL              : return "0NOTEQUAL";
231 | 	case OP_ADD                    : return "ADD";
232 | 	case OP_SUB                    : return "SUB";
233 | 	case OP_MUL                    : return "MUL";
234 | 	case OP_DIV                    : return "DIV";
235 | 	case OP_MOD                    : return "MOD";
236 | 	case OP_LSHIFT                 : return "LSHIFT";
237 | 	case OP_RSHIFT                 : return "RSHIFT";
238 | 	case OP_BOOLAND                : return "BOOLAND";
239 | 	case OP_BOOLOR                 : return "BOOLOR";
240 | 	case OP_NUMEQUAL               : return "NUMEQUAL";
241 | 	case OP_NUMEQUALVERIFY         : return "NUMEQUALVERIFY";
242 | 	case OP_NUMNOTEQUAL            : return "NUMNOTEQUAL";
243 | 	case OP_LESSTHAN               : return "LESSTHAN";
244 | 	case OP_GREATERTHAN            : return "GREATERTHAN";
245 | 	case OP_LESSTHANOREQUAL        : return "LESSTHANOREQUAL";
246 | 	case OP_GREATERTHANOREQUAL     : return "GREATERTHANOREQUAL";
247 | 	case OP_MIN                    : return "MIN";
248 | 	case OP_MAX                    : return "MAX";
249 | 	case OP_WITHIN                 : return "WITHIN";
250 | 	
251 | 	// crypto
252 | 	case OP_RIPEMD160              : return "RIPEMD160";
253 | 	case OP_SHA1                   : return "SHA1";
254 | 	case OP_SHA256                 : return "SHA256";
255 | 	case OP_HASH160                : return "HASH160";
256 | 	case OP_HASH256                : return "HASH256";
257 | 	case OP_CODESEPARATOR          : return "CODESEPARATOR";
258 | 	case OP_CHECKSIG               : return "CHECKSIG";
259 | 	case OP_CHECKSIGVERIFY         : return "CHECKSIGVERIFY";
260 | 	case OP_CHECKMULTISIG          : return "CHECKMULTISIG";
261 | 	case OP_CHECKMULTISIGVERIFY    : return "CHECKMULTISIGVERIFY";
262 | 	
263 | 	// expansion
264 | 	case OP_NOP1                   : return "NOP1";
265 | 	case OP_CHECKLOCKTIMEVERIFY    : return "CHECKLOCKTIMEVERIFY";
266 | 	case OP_CHECKSEQUENCEVERIFY    : return "CHECKSEQUENCEVERIFY";
267 | 	case OP_NOP4                   : return "NOP4";
268 | 	case OP_NOP5                   : return "NOP5";
269 | 	case OP_NOP6                   : return "NOP6";
270 | 	case OP_NOP7                   : return "NOP7";
271 | 	case OP_NOP8                   : return "NOP8";
272 | 	case OP_NOP9                   : return "NOP9";
273 | 	case OP_NOP10                  : return "NOP10";
274 | 	
275 | 	case OP_INVALIDOPCODE          : return "INVALIDOPCODE";
276 | 	
277 | 	// Note:
278 | 	//  The template matching params OP_SMALLINTEGER/etc are defined in opcodetype enum
279 | 	//  as kind of implementation hack, they are *NOT* real opcodes.  If found in real
280 | 	//  Script, just let the default: case deal with them.
281 | 	
282 | 	default: {
283 | 	  static char buf[32];
284 | 	  sprintf(buf, "%02x", opcode);
285 | 	  return buf;
286 | 	}
287 | 	}
288 | }
289 | 
290 | 
291 | 
292 | 
293 | static u32
294 | hash_fnv(u32 d, const char *str) {
295 | 	u8 *p = (u8*)str;
296 | 
297 | 	if (d == 0)
298 | 		d = 0x01000193;
299 | 
300 | 	while(*p)
301 | 		d = ((d * 0x01000193) ^ *p++) & 0xffffffff;
302 | 
303 | 	return d;
304 | }
305 | 
306 | 
307 | enum opcode_token
308 | op_hash(const char *str) {
309 | 	int d = opcodes_g[hash_fnv(0, str) % ARRAY_SIZE(opcodes_g)];
310 | 	if (d < 0) d = opcodes_v[-d-1];
311 | 	else       d = opcodes_v[hash_fnv(d, str) % ARRAY_SIZE(opcodes_v)];
312 | 	return d;
313 | }
314 | 
315 | 
316 | 
317 | const char *
318 | op_normalized_tok(const char *tok, int hash) {
319 | 	if (hash != _OP_TRUE	&&
320 | 			hash != _OP_FALSE &&
321 | 			hash != _OP_NOP2	&&
322 | 			hash != _OP_NOP3) return tok;
323 | 
324 | 	if (strcmp(tok, "TRUE") == 0) return "1";
325 | 	else if (strcmp(tok, "FALSE") == 0) return "0";
326 | 	else if (strcmp(tok, "NOP2") == 0) return "CHECKLOCKTIMEVERIFY";
327 | 	else if (strcmp(tok, "NOP3") == 0) return "CHECKSEQUENCEVERIFY";
328 | 
329 | 	return tok;
330 | }
331 | 
332 | 
333 | enum opcode
334 | op_parse_opcode(const char *str) {
335 | 	int hash		 = op_hash(str);
336 | 	int maybe_op = op_from_token(hash);
337 | 
338 | 	if (strcmp(op_name(maybe_op), op_normalized_tok(str, hash)) == 0)
339 | 		return maybe_op;
340 | 	else
341 | 		return OP_INVALIDOPCODE;
342 | }
343 | 
344 | 
345 | enum opcode
346 | op_tokenize(char *str) {
347 | 	int i;
348 | 
349 | 	for (i = 0; str[i]; ++i)
350 | 		str[i] = toupper(str[i]);
351 | 
352 | 	return op_parse_opcode(str);
353 | }
354 | 
355 | 
356 | void
357 | val_print(struct val val) {
358 | 	struct num *n;
359 | 	switch(val.type) {
360 | 	case VT_SCRIPTNUM:
361 | 		assert(val.ind != -1);
362 | 		n = num_pool_get(val.ind);
363 | 		assert(n);
364 | 		printf("%" PRId64, n->val);
365 | 		break;
366 | 	case VT_OP:
367 | 		printf("OP_%s", op_name(val.ind));
368 | 		break;
369 | 	case VT_SMALLINT:
370 | 		printf("%d", val.ind);
371 | 		break;
372 | 	case VT_DATA: {
373 | 		u32 len;
374 | 		u8 *data = byte_pool_get(val.ind, &len);
375 | 
376 | 		if (len == 0)
377 | 			printf("0");
378 | 		else
379 | 			printf("@");
380 | 
381 | 		print_bytes(data, len, 0);
382 | 		break;
383 | 	}
384 | 	case VT_RAW: {
385 | 		u32 len;
386 | 		u8 *data = byte_pool_get(val.ind, &len);
387 | 		printf("0x");
388 | 		print_bytes(data, len, 0);
389 | 		break;
390 | 	}
391 | 	default:
392 | 		assert(!"val_print data");
393 | 	}
394 | }
395 | 
396 | const char *
397 | val_name(struct val val) {
398 | 	switch(val.type) {
399 | 	case VT_SCRIPTNUM:	return "n"; break;
400 | 	case VT_SMALLINT:  return "s"; break;
401 | 	case VT_DATA: return "d"; break;
402 | 	}
403 | 	return "UNK_VAL";
404 | }
405 | 


--------------------------------------------------------------------------------
/ripemd160.c:
--------------------------------------------------------------------------------
  1 | /* MIT (BSD) license - see LICENSE file for details */
  2 | /* RIPEMD core code translated from the Bitcoin project's C++:
  3 |  *
  4 |  * src/crypto/ripemd160.cpp commit f914f1a746d7f91951c1da262a4a749dd3ebfa71
  5 |  * Copyright (c) 2014 The Bitcoin Core developers
  6 |  * Distributed under the MIT software license, see the accompanying
  7 |  * file COPYING or http://www.opensource.org/licenses/mit-license.php.
  8 |  */
  9 | #include "ripemd160.h"
 10 | #include "endian.h"
 11 | #include "compiler.h"
 12 | #include <stdbool.h>
 13 | #include <assert.h>
 14 | #include <string.h>
 15 | 
 16 | static void invalidate_ripemd160(struct ripemd160_ctx *ctx)
 17 | {
 18 | #ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL
 19 | 	ctx->c.num = -1U;
 20 | #else
 21 | 	ctx->bytes = -1ULL;
 22 | #endif
 23 | }
 24 | 
 25 | static void check_ripemd160(struct ripemd160_ctx *ctx)
 26 | {
 27 | #ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL
 28 | 	assert(ctx->c.num != -1U);
 29 | #else
 30 | 	assert(ctx->bytes != -1ULL);
 31 | #endif
 32 | }
 33 | 
 34 | #ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL
 35 | void ripemd160_init(struct ripemd160_ctx *ctx)
 36 | {
 37 | 	RIPEMD160_Init(&ctx->c);
 38 | }
 39 | 
 40 | void ripemd160_update(struct ripemd160_ctx *ctx, const void *p, size_t size)
 41 | {
 42 | 	check_ripemd160(ctx);
 43 | 	RIPEMD160_Update(&ctx->c, p, size);
 44 | }
 45 | 
 46 | void ripemd160_done(struct ripemd160_ctx *ctx, struct ripemd160 *res)
 47 | {
 48 | 	RIPEMD160_Final(res->u.u8, &ctx->c);
 49 | 	invalidate_ripemd160(ctx);
 50 | }
 51 | #else
 52 | inline static uint32_t f1(uint32_t x, uint32_t y, uint32_t z) { return x ^ y ^ z; }
 53 | inline static uint32_t f2(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (~x & z); }
 54 | inline static uint32_t f3(uint32_t x, uint32_t y, uint32_t z) { return (x | ~y) ^ z; }
 55 | inline static uint32_t f4(uint32_t x, uint32_t y, uint32_t z) { return (x & z) | (y & ~z); }
 56 | inline static uint32_t f5(uint32_t x, uint32_t y, uint32_t z) { return x ^ (y | ~z); }
 57 | 
 58 | /** Initialize RIPEMD-160 state. */
 59 | inline static void Initialize(uint32_t* s)
 60 | {
 61 |     s[0] = 0x67452301ul;
 62 |     s[1] = 0xEFCDAB89ul;
 63 |     s[2] = 0x98BADCFEul;
 64 |     s[3] = 0x10325476ul;
 65 |     s[4] = 0xC3D2E1F0ul;
 66 | }
 67 | 
 68 | inline static uint32_t rol(uint32_t x, int i) { return (x << i) | (x >> (32 - i)); }
 69 | 
 70 | inline static void Round(uint32_t *a, uint32_t b UNUSED, uint32_t *c, uint32_t d UNUSED, uint32_t e, uint32_t f, uint32_t x, uint32_t k, int r)
 71 | {
 72 |     *a = rol(*a + f + x + k, r) + e;
 73 |     *c = rol(*c, 10);
 74 | }
 75 | 
 76 | inline static void R11(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, *c, d), x, 0, r); }
 77 | inline static void R21(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f2(b, *c, d), x, 0x5A827999ul, r); }
 78 | inline static void R31(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f3(b, *c, d), x, 0x6ED9EBA1ul, r); }
 79 | inline static void R41(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f4(b, *c, d), x, 0x8F1BBCDCul, r); }
 80 | inline static void R51(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f5(b, *c, d), x, 0xA953FD4Eul, r); }
 81 | 
 82 | inline static void R12(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f5(b, *c, d), x, 0x50A28BE6ul, r); }
 83 | inline static void R22(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f4(b, *c, d), x, 0x5C4DD124ul, r); }
 84 | inline static void R32(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f3(b, *c, d), x, 0x6D703EF3ul, r); }
 85 | inline static void R42(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f2(b, *c, d), x, 0x7A6D76E9ul, r); }
 86 | inline static void R52(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, *c, d), x, 0, r); }
 87 | 
 88 | /** Perform a RIPEMD-160 transformation, processing a 64-byte chunk. */
 89 | static void Transform(uint32_t *s, const uint32_t *chunk)
 90 | {
 91 |     uint32_t a1 = s[0], b1 = s[1], c1 = s[2], d1 = s[3], e1 = s[4];
 92 |     uint32_t a2 = a1, b2 = b1, c2 = c1, d2 = d1, e2 = e1;
 93 |     uint32_t w0 = le32_to_cpu(chunk[0]), w1 = le32_to_cpu(chunk[1]), w2 = le32_to_cpu(chunk[2]), w3 = le32_to_cpu(chunk[3]);
 94 |     uint32_t w4 = le32_to_cpu(chunk[4]), w5 = le32_to_cpu(chunk[5]), w6 = le32_to_cpu(chunk[6]), w7 = le32_to_cpu(chunk[7]);
 95 |     uint32_t w8 = le32_to_cpu(chunk[8]), w9 = le32_to_cpu(chunk[9]), w10 = le32_to_cpu(chunk[10]), w11 = le32_to_cpu(chunk[11]);
 96 |     uint32_t w12 = le32_to_cpu(chunk[12]), w13 = le32_to_cpu(chunk[13]), w14 = le32_to_cpu(chunk[14]), w15 = le32_to_cpu(chunk[15]);
 97 |     uint32_t t;
 98 | 
 99 |     R11(&a1, b1, &c1, d1, e1, w0, 11);
100 |     R12(&a2, b2, &c2, d2, e2, w5, 8);
101 |     R11(&e1, a1, &b1, c1, d1, w1, 14);
102 |     R12(&e2, a2, &b2, c2, d2, w14, 9);
103 |     R11(&d1, e1, &a1, b1, c1, w2, 15);
104 |     R12(&d2, e2, &a2, b2, c2, w7, 9);
105 |     R11(&c1, d1, &e1, a1, b1, w3, 12);
106 |     R12(&c2, d2, &e2, a2, b2, w0, 11);
107 |     R11(&b1, c1, &d1, e1, a1, w4, 5);
108 |     R12(&b2, c2, &d2, e2, a2, w9, 13);
109 |     R11(&a1, b1, &c1, d1, e1, w5, 8);
110 |     R12(&a2, b2, &c2, d2, e2, w2, 15);
111 |     R11(&e1, a1, &b1, c1, d1, w6, 7);
112 |     R12(&e2, a2, &b2, c2, d2, w11, 15);
113 |     R11(&d1, e1, &a1, b1, c1, w7, 9);
114 |     R12(&d2, e2, &a2, b2, c2, w4, 5);
115 |     R11(&c1, d1, &e1, a1, b1, w8, 11);
116 |     R12(&c2, d2, &e2, a2, b2, w13, 7);
117 |     R11(&b1, c1, &d1, e1, a1, w9, 13);
118 |     R12(&b2, c2, &d2, e2, a2, w6, 7);
119 |     R11(&a1, b1, &c1, d1, e1, w10, 14);
120 |     R12(&a2, b2, &c2, d2, e2, w15, 8);
121 |     R11(&e1, a1, &b1, c1, d1, w11, 15);
122 |     R12(&e2, a2, &b2, c2, d2, w8, 11);
123 |     R11(&d1, e1, &a1, b1, c1, w12, 6);
124 |     R12(&d2, e2, &a2, b2, c2, w1, 14);
125 |     R11(&c1, d1, &e1, a1, b1, w13, 7);
126 |     R12(&c2, d2, &e2, a2, b2, w10, 14);
127 |     R11(&b1, c1, &d1, e1, a1, w14, 9);
128 |     R12(&b2, c2, &d2, e2, a2, w3, 12);
129 |     R11(&a1, b1, &c1, d1, e1, w15, 8);
130 |     R12(&a2, b2, &c2, d2, e2, w12, 6);
131 | 
132 |     R21(&e1, a1, &b1, c1, d1, w7, 7);
133 |     R22(&e2, a2, &b2, c2, d2, w6, 9);
134 |     R21(&d1, e1, &a1, b1, c1, w4, 6);
135 |     R22(&d2, e2, &a2, b2, c2, w11, 13);
136 |     R21(&c1, d1, &e1, a1, b1, w13, 8);
137 |     R22(&c2, d2, &e2, a2, b2, w3, 15);
138 |     R21(&b1, c1, &d1, e1, a1, w1, 13);
139 |     R22(&b2, c2, &d2, e2, a2, w7, 7);
140 |     R21(&a1, b1, &c1, d1, e1, w10, 11);
141 |     R22(&a2, b2, &c2, d2, e2, w0, 12);
142 |     R21(&e1, a1, &b1, c1, d1, w6, 9);
143 |     R22(&e2, a2, &b2, c2, d2, w13, 8);
144 |     R21(&d1, e1, &a1, b1, c1, w15, 7);
145 |     R22(&d2, e2, &a2, b2, c2, w5, 9);
146 |     R21(&c1, d1, &e1, a1, b1, w3, 15);
147 |     R22(&c2, d2, &e2, a2, b2, w10, 11);
148 |     R21(&b1, c1, &d1, e1, a1, w12, 7);
149 |     R22(&b2, c2, &d2, e2, a2, w14, 7);
150 |     R21(&a1, b1, &c1, d1, e1, w0, 12);
151 |     R22(&a2, b2, &c2, d2, e2, w15, 7);
152 |     R21(&e1, a1, &b1, c1, d1, w9, 15);
153 |     R22(&e2, a2, &b2, c2, d2, w8, 12);
154 |     R21(&d1, e1, &a1, b1, c1, w5, 9);
155 |     R22(&d2, e2, &a2, b2, c2, w12, 7);
156 |     R21(&c1, d1, &e1, a1, b1, w2, 11);
157 |     R22(&c2, d2, &e2, a2, b2, w4, 6);
158 |     R21(&b1, c1, &d1, e1, a1, w14, 7);
159 |     R22(&b2, c2, &d2, e2, a2, w9, 15);
160 |     R21(&a1, b1, &c1, d1, e1, w11, 13);
161 |     R22(&a2, b2, &c2, d2, e2, w1, 13);
162 |     R21(&e1, a1, &b1, c1, d1, w8, 12);
163 |     R22(&e2, a2, &b2, c2, d2, w2, 11);
164 | 
165 |     R31(&d1, e1, &a1, b1, c1, w3, 11);
166 |     R32(&d2, e2, &a2, b2, c2, w15, 9);
167 |     R31(&c1, d1, &e1, a1, b1, w10, 13);
168 |     R32(&c2, d2, &e2, a2, b2, w5, 7);
169 |     R31(&b1, c1, &d1, e1, a1, w14, 6);
170 |     R32(&b2, c2, &d2, e2, a2, w1, 15);
171 |     R31(&a1, b1, &c1, d1, e1, w4, 7);
172 |     R32(&a2, b2, &c2, d2, e2, w3, 11);
173 |     R31(&e1, a1, &b1, c1, d1, w9, 14);
174 |     R32(&e2, a2, &b2, c2, d2, w7, 8);
175 |     R31(&d1, e1, &a1, b1, c1, w15, 9);
176 |     R32(&d2, e2, &a2, b2, c2, w14, 6);
177 |     R31(&c1, d1, &e1, a1, b1, w8, 13);
178 |     R32(&c2, d2, &e2, a2, b2, w6, 6);
179 |     R31(&b1, c1, &d1, e1, a1, w1, 15);
180 |     R32(&b2, c2, &d2, e2, a2, w9, 14);
181 |     R31(&a1, b1, &c1, d1, e1, w2, 14);
182 |     R32(&a2, b2, &c2, d2, e2, w11, 12);
183 |     R31(&e1, a1, &b1, c1, d1, w7, 8);
184 |     R32(&e2, a2, &b2, c2, d2, w8, 13);
185 |     R31(&d1, e1, &a1, b1, c1, w0, 13);
186 |     R32(&d2, e2, &a2, b2, c2, w12, 5);
187 |     R31(&c1, d1, &e1, a1, b1, w6, 6);
188 |     R32(&c2, d2, &e2, a2, b2, w2, 14);
189 |     R31(&b1, c1, &d1, e1, a1, w13, 5);
190 |     R32(&b2, c2, &d2, e2, a2, w10, 13);
191 |     R31(&a1, b1, &c1, d1, e1, w11, 12);
192 |     R32(&a2, b2, &c2, d2, e2, w0, 13);
193 |     R31(&e1, a1, &b1, c1, d1, w5, 7);
194 |     R32(&e2, a2, &b2, c2, d2, w4, 7);
195 |     R31(&d1, e1, &a1, b1, c1, w12, 5);
196 |     R32(&d2, e2, &a2, b2, c2, w13, 5);
197 | 
198 |     R41(&c1, d1, &e1, a1, b1, w1, 11);
199 |     R42(&c2, d2, &e2, a2, b2, w8, 15);
200 |     R41(&b1, c1, &d1, e1, a1, w9, 12);
201 |     R42(&b2, c2, &d2, e2, a2, w6, 5);
202 |     R41(&a1, b1, &c1, d1, e1, w11, 14);
203 |     R42(&a2, b2, &c2, d2, e2, w4, 8);
204 |     R41(&e1, a1, &b1, c1, d1, w10, 15);
205 |     R42(&e2, a2, &b2, c2, d2, w1, 11);
206 |     R41(&d1, e1, &a1, b1, c1, w0, 14);
207 |     R42(&d2, e2, &a2, b2, c2, w3, 14);
208 |     R41(&c1, d1, &e1, a1, b1, w8, 15);
209 |     R42(&c2, d2, &e2, a2, b2, w11, 14);
210 |     R41(&b1, c1, &d1, e1, a1, w12, 9);
211 |     R42(&b2, c2, &d2, e2, a2, w15, 6);
212 |     R41(&a1, b1, &c1, d1, e1, w4, 8);
213 |     R42(&a2, b2, &c2, d2, e2, w0, 14);
214 |     R41(&e1, a1, &b1, c1, d1, w13, 9);
215 |     R42(&e2, a2, &b2, c2, d2, w5, 6);
216 |     R41(&d1, e1, &a1, b1, c1, w3, 14);
217 |     R42(&d2, e2, &a2, b2, c2, w12, 9);
218 |     R41(&c1, d1, &e1, a1, b1, w7, 5);
219 |     R42(&c2, d2, &e2, a2, b2, w2, 12);
220 |     R41(&b1, c1, &d1, e1, a1, w15, 6);
221 |     R42(&b2, c2, &d2, e2, a2, w13, 9);
222 |     R41(&a1, b1, &c1, d1, e1, w14, 8);
223 |     R42(&a2, b2, &c2, d2, e2, w9, 12);
224 |     R41(&e1, a1, &b1, c1, d1, w5, 6);
225 |     R42(&e2, a2, &b2, c2, d2, w7, 5);
226 |     R41(&d1, e1, &a1, b1, c1, w6, 5);
227 |     R42(&d2, e2, &a2, b2, c2, w10, 15);
228 |     R41(&c1, d1, &e1, a1, b1, w2, 12);
229 |     R42(&c2, d2, &e2, a2, b2, w14, 8);
230 | 
231 |     R51(&b1, c1, &d1, e1, a1, w4, 9);
232 |     R52(&b2, c2, &d2, e2, a2, w12, 8);
233 |     R51(&a1, b1, &c1, d1, e1, w0, 15);
234 |     R52(&a2, b2, &c2, d2, e2, w15, 5);
235 |     R51(&e1, a1, &b1, c1, d1, w5, 5);
236 |     R52(&e2, a2, &b2, c2, d2, w10, 12);
237 |     R51(&d1, e1, &a1, b1, c1, w9, 11);
238 |     R52(&d2, e2, &a2, b2, c2, w4, 9);
239 |     R51(&c1, d1, &e1, a1, b1, w7, 6);
240 |     R52(&c2, d2, &e2, a2, b2, w1, 12);
241 |     R51(&b1, c1, &d1, e1, a1, w12, 8);
242 |     R52(&b2, c2, &d2, e2, a2, w5, 5);
243 |     R51(&a1, b1, &c1, d1, e1, w2, 13);
244 |     R52(&a2, b2, &c2, d2, e2, w8, 14);
245 |     R51(&e1, a1, &b1, c1, d1, w10, 12);
246 |     R52(&e2, a2, &b2, c2, d2, w7, 6);
247 |     R51(&d1, e1, &a1, b1, c1, w14, 5);
248 |     R52(&d2, e2, &a2, b2, c2, w6, 8);
249 |     R51(&c1, d1, &e1, a1, b1, w1, 12);
250 |     R52(&c2, d2, &e2, a2, b2, w2, 13);
251 |     R51(&b1, c1, &d1, e1, a1, w3, 13);
252 |     R52(&b2, c2, &d2, e2, a2, w13, 6);
253 |     R51(&a1, b1, &c1, d1, e1, w8, 14);
254 |     R52(&a2, b2, &c2, d2, e2, w14, 5);
255 |     R51(&e1, a1, &b1, c1, d1, w11, 11);
256 |     R52(&e2, a2, &b2, c2, d2, w0, 15);
257 |     R51(&d1, e1, &a1, b1, c1, w6, 8);
258 |     R52(&d2, e2, &a2, b2, c2, w3, 13);
259 |     R51(&c1, d1, &e1, a1, b1, w15, 5);
260 |     R52(&c2, d2, &e2, a2, b2, w9, 11);
261 |     R51(&b1, c1, &d1, e1, a1, w13, 6);
262 |     R52(&b2, c2, &d2, e2, a2, w11, 11);
263 | 
264 |     t = s[0];
265 |     s[0] = s[1] + c1 + d2;
266 |     s[1] = s[2] + d1 + e2;
267 |     s[2] = s[3] + e1 + a2;
268 |     s[3] = s[4] + a1 + b2;
269 |     s[4] = t + b1 + c2;
270 | }
271 | 
272 | static void add(struct ripemd160_ctx *ctx, const void *p, size_t len)
273 | {
274 | 	const unsigned char *data = p;
275 | 	size_t bufsize = ctx->bytes % 64;
276 | 
277 | 	if (bufsize + len >= 64) {
278 | 		/* Fill the buffer, and process it. */
279 | 		memcpy(ctx->buf.u8 + bufsize, data, 64 - bufsize);
280 | 		ctx->bytes += 64 - bufsize;
281 | 		data += 64 - bufsize;
282 | 		len -= 64 - bufsize;
283 | 		Transform(ctx->s, ctx->buf.u32);
284 | 		bufsize = 0;
285 | 	}
286 | 
287 | 	while (len >= 64) {
288 | 		/* Process full chunks directly from the source. */
289 | 		if (alignment_ok(data, sizeof(uint32_t)))
290 | 			Transform(ctx->s, (const uint32_t *)data);
291 | 		else {
292 | 			memcpy(ctx->buf.u8, data, sizeof(ctx->buf));
293 | 			Transform(ctx->s, ctx->buf.u32);
294 | 		}
295 | 		ctx->bytes += 64;
296 | 		data += 64;
297 | 		len -= 64;
298 | 	}
299 | 
300 | 	if (len) {
301 | 		/* Fill the buffer with what remains. */
302 | 		memcpy(ctx->buf.u8 + bufsize, data, len);
303 | 		ctx->bytes += len;
304 | 	}
305 | }
306 | 
307 | void ripemd160_init(struct ripemd160_ctx *ctx)
308 | {
309 | 	struct ripemd160_ctx init = RIPEMD160_INIT;
310 | 	*ctx = init;
311 | }
312 | 
313 | void ripemd160_update(struct ripemd160_ctx *ctx, const void *p, size_t size)
314 | {
315 | 	check_ripemd160(ctx);
316 | 	add(ctx, p, size);
317 | }
318 | 
319 | void ripemd160_done(struct ripemd160_ctx *ctx, struct ripemd160 *res)
320 | {
321 | 	static const unsigned char pad[64] = {0x80};
322 | 	uint64_t sizedesc;
323 | 	size_t i;
324 | 
325 | 	sizedesc = cpu_to_le64(ctx->bytes << 3);
326 | 	/* Add '1' bit to terminate, then all 0 bits, up to next block - 8. */
327 | 	add(ctx, pad, 1 + ((119 - (ctx->bytes % 64)) % 64));
328 | 	/* Add number of bits of data (big endian) */
329 | 	add(ctx, &sizedesc, 8);
330 | 	for (i = 0; i < sizeof(ctx->s) / sizeof(ctx->s[0]); i++)
331 | 		res->u.u32[i] = cpu_to_le32(ctx->s[i]);
332 | 	invalidate_ripemd160(ctx);
333 | }
334 | #endif
335 | 
336 | void ripemd160(struct ripemd160 *ripemd, const void *p, size_t size)
337 | {
338 | 	struct ripemd160_ctx ctx;
339 | 
340 | 	ripemd160_init(&ctx);
341 | 	ripemd160_update(&ctx, p, size);
342 | 	ripemd160_done(&ctx, ripemd);
343 | 	memset(&ctx, 0, sizeof(ctx));
344 | }
345 | 
346 | void ripemd160_u8(struct ripemd160_ctx *ctx, uint8_t v)
347 | {
348 | 	ripemd160_update(ctx, &v, sizeof(v));
349 | }
350 | 
351 | void ripemd160_u16(struct ripemd160_ctx *ctx, uint16_t v)
352 | {
353 | 	ripemd160_update(ctx, &v, sizeof(v));
354 | }
355 | 
356 | void ripemd160_u32(struct ripemd160_ctx *ctx, uint32_t v)
357 | {
358 | 	ripemd160_update(ctx, &v, sizeof(v));
359 | }
360 | 
361 | void ripemd160_u64(struct ripemd160_ctx *ctx, uint64_t v)
362 | {
363 | 	ripemd160_update(ctx, &v, sizeof(v));
364 | }
365 | 
366 | /* Add as little-endian */
367 | void ripemd160_le16(struct ripemd160_ctx *ctx, uint16_t v)
368 | {
369 | 	leint16_t lev = cpu_to_le16(v);
370 | 	ripemd160_update(ctx, &lev, sizeof(lev));
371 | }
372 | 
373 | void ripemd160_le32(struct ripemd160_ctx *ctx, uint32_t v)
374 | {
375 | 	leint32_t lev = cpu_to_le32(v);
376 | 	ripemd160_update(ctx, &lev, sizeof(lev));
377 | }
378 | 
379 | void ripemd160_le64(struct ripemd160_ctx *ctx, uint64_t v)
380 | {
381 | 	leint64_t lev = cpu_to_le64(v);
382 | 	ripemd160_update(ctx, &lev, sizeof(lev));
383 | }
384 | 
385 | /* Add as big-endian */
386 | void ripemd160_be16(struct ripemd160_ctx *ctx, uint16_t v)
387 | {
388 | 	beint16_t bev = cpu_to_be16(v);
389 | 	ripemd160_update(ctx, &bev, sizeof(bev));
390 | }
391 | 
392 | void ripemd160_be32(struct ripemd160_ctx *ctx, uint32_t v)
393 | {
394 | 	beint32_t bev = cpu_to_be32(v);
395 | 	ripemd160_update(ctx, &bev, sizeof(bev));
396 | }
397 | 
398 | void ripemd160_be64(struct ripemd160_ctx *ctx, uint64_t v)
399 | {
400 | 	beint64_t bev = cpu_to_be64(v);
401 | 	ripemd160_update(ctx, &bev, sizeof(bev));
402 | }
403 | 
404 | 
405 | 


--------------------------------------------------------------------------------
/script.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "script.h"
  3 | #include "op.h"
  4 | #include "script_num.h"
  5 | #include "stack.h"
  6 | #include "alloc.h"
  7 | #include "valstack.h"
  8 | #include "compiler.h"
  9 | #include "sha256.h"
 10 | #include "ripemd160.h"
 11 | #include <stdio.h>
 12 | #include <inttypes.h>
 13 | 
 14 | /* #define SCRIPTERR(serr) script_add_error(c, opcode, serr) */
 15 | #define SCRIPTERR(serr) { err = serr; goto evalerror; }
 16 | 
 17 | int g_silence_script_err = 0;
 18 | int g_silence_script_warn = 0;
 19 | 
 20 | int script_add_error(int c, enum opcode cur_op, const char *serror) {
 21 | 	// TODO: set_error
 22 | 	if (!g_silence_script_err)
 23 | 		fprintf(stderr, "error: %s @ op %d (%s)\n", serror, c, op_name(cur_op));
 24 | 	return 0;
 25 | }
 26 | 
 27 | void script_add_warning(const char *warning) {
 28 | 	// TODO: set_error
 29 | 	if (!g_silence_script_warn)
 30 | 		fprintf(stderr, "warning: %s\n", warning);
 31 | }
 32 | 
 33 | 
 34 | int
 35 | cast_to_bool(struct val val) {
 36 | 	// TODO: implement cast_to_bool
 37 | 	switch (val.type) {
 38 | 	case VT_SMALLINT:
 39 | 		return val.ind != 0;
 40 | 	case VT_SCRIPTNUM: {
 41 | 		struct num *sn = num_pool_get(val.ind);
 42 | 		return sn->val != 0;
 43 | 	}
 44 | 	case VT_DATA: {
 45 | 		u32 len;
 46 | 		const u8 * bytes = byte_pool_get(val.ind, &len);
 47 | 		return *bytes != 0;
 48 | 	}
 49 | 	}
 50 | 	assert(!"Unhandled val.type in cast_to_bool");
 51 | }
 52 | 
 53 | int script_getop(const u8 **p, const u8 *end, enum opcode *popcode, u8 *buf,
 54 | 		 int bufsize, u32 *outlen)
 55 | {
 56 | 	*popcode = OP_INVALIDOPCODE;
 57 | 	u32 nsize = 0;
 58 | 
 59 | 	int opcode;
 60 | 
 61 | 	if (buf)
 62 | 		memset(buf, 0, bufsize);
 63 | 
 64 | 	opcode = **p;
 65 | 	*p += 1;
 66 | 
 67 | 	if (opcode <= OP_PUSHDATA4) {
 68 | 		if (opcode < OP_PUSHDATA1) {
 69 | 			nsize = opcode;
 70 | 		}
 71 | 		else {
 72 | 			switch (opcode) {
 73 | 			case OP_PUSHDATA1:
 74 | 				if ((end - *p) < 1) {
 75 | 					return 0;
 76 | 				}
 77 | 				nsize = **p;
 78 | 				(*p)++;
 79 | 				break;
 80 | 			case OP_PUSHDATA2:
 81 | 				if ((end - *p) < 2) {
 82 | 					return 0;
 83 | 				}
 84 | 				nsize = **(u16**)p;
 85 | 				*p += 2;
 86 | 				break;
 87 | 			case OP_PUSHDATA4:
 88 | 				if ((end - *p) < 4) {
 89 | 					return 0;
 90 | 				}
 91 | 				nsize = **(u32**)p;
 92 | 				*p += 4;
 93 | 				break;
 94 | 			default:
 95 | 				break;
 96 | 			}
 97 | 		}
 98 | 
 99 | 		if ((end - *p) < 0 || (end - *p) < nsize) {
100 | 			return 0;
101 | 		}
102 | 
103 | 		if (buf) {
104 | 			*outlen = nsize;
105 | 			memcpy(buf, *p, nsize);
106 | 		}
107 | 		*p += nsize;
108 | 	}
109 | 
110 | 	*popcode = opcode;
111 | 
112 | 	return 1;
113 | }
114 | 
115 | 
116 | int
117 | script_eval(const u8 *script, size_t script_size, struct stack *stack,
118 | 						struct result *result) {
119 | 	int op_count = 0;
120 | 	u32 tmplen = 0;
121 | 	char *err = NULL;
122 | 	const u8 *p = script;
123 | 	const u8 *top = script + script_size;
124 | 	static char tmpbuf[32];
125 | 	static u8 tmpbytes[MAX_SCRIPT_ELEMENT_SIZE];
126 | 	static u8 tmpbytes2[MAX_SCRIPT_ELEMENT_SIZE];
127 | 	enum opcode opcode;
128 | 	struct val val_true = val_from_int(1);
129 | 	struct val val_false = val_from_int(0);
130 | 	static const struct num bn_one	= {.val = 1, .ind = -1};
131 | 	static const struct num bn_zero = {.val = 0, .ind = -1};
132 | 	struct val val;
133 | 	struct stack _altstack;
134 | 	struct stack _ifstack;
135 | 	struct stack *altstack = &_altstack;
136 | 	struct stack *ifstack = &_ifstack;
137 | 	int flags = CO_WARNINGS_ARE_ERRORS | CO_WARN_MINIMAL;
138 | 	int c = 0;
139 | 	// TODO: require minimal?
140 | 	int require_minimal =
141 | 		!(flags & ~(CO_WARNINGS_ARE_ERRORS | CO_WARN_MINIMAL));
142 | 	stack_init(altstack);
143 | 	stack_init(ifstack);
144 | 
145 | 	while (p < top) {
146 | 		c++;
147 | 		script_getop(&p, top, &opcode, tmpbytes, sizeof(tmpbytes), &tmplen);
148 | 		int if_exec = !stack_any_val(ifstack, falseval);
149 | 
150 | 		// Note OP_RESERVED does not count towards the opcode limit.
151 | 		if (opcode > OP_16 && ++op_count > MAX_OPS_PER_SCRIPT)
152 | 			SCRIPTERR("MAX_OPS_PER_SCRIPT");
153 | 
154 | 		if ( opcode == OP_SUBSTR ||
155 | 				opcode == OP_LEFT ||
156 | 				opcode == OP_RIGHT ||
157 | 				opcode == OP_INVERT ||
158 | 				opcode == OP_AND ||
159 | 				opcode == OP_OR ||
160 | 				opcode == OP_XOR ||
161 | 				opcode == OP_2MUL ||
162 | 				opcode == OP_2DIV ||
163 | 				opcode == OP_MUL ||
164 | 				opcode == OP_DIV ||
165 | 				opcode == OP_MOD ||
166 | 				opcode == OP_LSHIFT ||
167 | 				opcode == OP_RSHIFT) {
168 | 
169 | 			SCRIPTERR("DISABLED_OPCODE"); // Disabled opcodes.
170 | 		}
171 | 
172 | 		if (if_exec && opcode <= OP_PUSHDATA4) {
173 | 			/* if (fRequireMinimal && !CheckMinimalPush(vchPushValue, opcode)) { */
174 | 			/*	 return set_error(serror, MINIMALDATA); */
175 | 			/* } */
176 | 			stack_push_raw(stack, tmpbytes, tmplen);
177 | 		} else if (if_exec || (OP_IF <= opcode && opcode <= OP_ENDIF))
178 | 		switch (opcode) {
179 | 		case OP_1NEGATE:
180 | 		case OP_1:
181 | 		case OP_2:
182 | 		case OP_3:
183 | 		case OP_4:
184 | 		case OP_5:
185 | 		case OP_6:
186 | 		case OP_7:
187 | 		case OP_8:
188 | 		case OP_9:
189 | 		case OP_10:
190 | 		case OP_11:
191 | 		case OP_12:
192 | 		case OP_13:
193 | 		case OP_14:
194 | 		case OP_15:
195 | 		case OP_16:
196 | 		{
197 | 			struct num sn;
198 | 			sn_from_int((int)opcode - (int)(OP_1 - 1), &sn);
199 | 			struct val val = sn_to_val(&sn);
200 | 			stack_push_val(stack, val);
201 | 		}
202 | 		break;
203 | 
204 | 		case OP_NOP: break;
205 | 
206 | 		case OP_CAT: {
207 | 			if (stack_size(stack) < 2)
208 | 				SCRIPTERR("INVALID_STACK_OPERATION");
209 | 			struct val a = stack_pop_val(stack);
210 | 			struct val b = stack_pop_val(stack);
211 | 			struct val c = val_cat(a, b);
212 | 			stack_push_val(stack, c);
213 | 
214 | 			break;
215 | 		}
216 | 
217 | 		case OP_NOP1: case OP_NOP4: case OP_NOP5:
218 | 		case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10:
219 | 			{
220 | 				/* if (script->flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS) */
221 | 				script_add_warning("DISCOURAGE_UPGRADABLE_NOPS");
222 | 			}
223 | 			break;
224 | 
225 | 		case OP_IF:
226 | 		case OP_NOTIF:
227 | 		{
228 | 			// <expression> if [statements] [else [statements]] endif
229 | 			int ifval = 0;
230 | 			if (if_exec)
231 | 			{
232 | 				if (stack_size(stack) < 1)
233 | 					SCRIPTERR("UNBALANCED_CONDITIONAL");
234 | 				struct val val = stack_top_val(stack, -1);
235 | 				// TODO: minimal if?
236 | 				// https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2016-August/013014.html
237 | 				/* if (sigversion == SIGVERSION_WITNESS_V0 && (flags & SCRIPT_VERIFY_MINIMALIF)) { */
238 | 				/*		 if (vch.size() > 1) */
239 | 				/*				 SCRIPTERR(MINIMALIF); */
240 | 				/*		 if (vch.size() == 1 && vch[0] != 1) */
241 | 				/*				 SCRIPTERR(MINIMALIF); */
242 | 				/* } */
243 | 				ifval = cast_to_bool(val);
244 | 				if (opcode == OP_NOTIF)
245 | 						ifval = !ifval;
246 | 				stack_pop(stack);
247 | 			}
248 | 			stack_push_val(ifstack, smallintval(ifval));
249 | 		}
250 | 		break;
251 | 
252 | 		case OP_ELSE:
253 | 		{
254 | 			if (stack_size(ifstack) == 0)
255 | 				SCRIPTERR("UNBALANCED_CONDITIONAL");
256 | 			struct val v = stack_pop_val(ifstack);
257 | 			assert(v.type == VT_SMALLINT);
258 | 			v.ind = !v.ind;
259 | 			stack_push_val(ifstack, v);
260 | 		}
261 | 		break;
262 | 
263 | 		case OP_ENDIF:
264 | 		{
265 | 			if (stack_size(ifstack) == 0)
266 | 				SCRIPTERR("UNBALANCED_CONDITIONAL");
267 | 			stack_pop(ifstack);
268 | 		}
269 | 		break;
270 | 
271 | 		case OP_RETURN:
272 | 		{
273 | 			SCRIPTERR("OP_RETURN");
274 | 		}
275 | 		break;
276 | 
277 | 		case OP_INVALIDOPCODE:
278 | 		{
279 | 			SCRIPTERR("INVALID_OPCODE");
280 | 		}
281 | 		break;
282 | 
283 | 		case OP_FROMALTSTACK:
284 | 		{
285 | 				if (stack_size(altstack) < 1)
286 | 					SCRIPTERR("INVALID_ALTSTACK_OPERATION");
287 | 				stack_push(stack, stack_top(altstack, -1));
288 | 				stack_pop(altstack);
289 | 		}
290 | 		break;
291 | 
292 | 		case OP_2DROP:
293 | 		{
294 | 			// (x1 x2 -- )
295 | 			if (stack_size(stack) < 2)
296 | 				SCRIPTERR("INVALID_STACK_OPERATION");
297 | 			stack_pop(stack);
298 | 			stack_pop(stack);
299 | 		}
300 | 		break;
301 | 
302 | 		case OP_2DUP:
303 | 		{
304 | 			// (x1 x2 -- x1 x2 x1 x2)
305 | 			if (stack_size(stack) < 2)
306 | 				SCRIPTERR("INVALID_STACK_OPERATION");
307 | 			struct val v1 = stack_top_val(stack, -2);
308 | 			struct val v2 = stack_top_val(stack, -1);
309 | 			stack_push_val(stack, val_copy(v1));
310 | 			stack_push_val(stack, val_copy(v2));
311 | 		}
312 | 		break;
313 | 
314 | 		case OP_3DUP:
315 | 		{
316 | 			// (x1 x2 x3 -- x1 x2 x3 x1 x2 x3)
317 | 			if (stack_size(stack) < 3)
318 | 				SCRIPTERR("INVALID_STACK_OPERATION");
319 | 			struct val v1 = stack_top_val(stack, -3);
320 | 			struct val v2 = stack_top_val(stack, -2);
321 | 			struct val v3 = stack_top_val(stack, -1);
322 | 			stack_push_val(stack, val_copy(v1));
323 | 			stack_push_val(stack, val_copy(v2));
324 | 			stack_push_val(stack, val_copy(v3));
325 | 		}
326 | 		break;
327 | 
328 | 		case OP_2OVER:
329 | 		{
330 | 			// (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2)
331 | 			if (stack_size(stack) < 4)
332 | 				SCRIPTERR("INVALID_STACK_OPERATION");
333 | 			struct val v1 = stack_top_val(stack, -4);
334 | 			struct val v2 = stack_top_val(stack, -3);
335 | 			stack_push_val(stack, val_copy(v1));
336 | 			stack_push_val(stack, val_copy(v2));
337 | 		}
338 | 		break;
339 | 
340 | 		case OP_2ROT:
341 | 		{
342 | 			// (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2)
343 | 			if (stack_size(stack) < 6)
344 | 				SCRIPTERR("INVALID_STACK_OPERATION");
345 | 			struct val t6 = stack_top_val(stack, -6);
346 | 			struct val t5 = stack_top_val(stack, -5);
347 | 			*(stack->top - 6) = *(stack->top - 4);
348 | 			*(stack->top - 5) = *(stack->top - 3);
349 | 			*(stack->top - 4) = *(stack->top - 2);
350 | 			*(stack->top - 3) = *(stack->top - 1);
351 | 			stack_set_val(stack, -2, t6);
352 | 			stack_set_val(stack, -1, t5);
353 | 		}
354 | 		break;
355 | 
356 | 		case OP_2SWAP:
357 | 		{
358 | 			// (x1 x2 x3 x4 -- x3 x4 x1 x2)
359 | 			if (stack_size(stack) < 4)
360 | 				SCRIPTERR("INVALID_STACK_OPERATION");
361 | 
362 | 			struct val t4 = stack_top_val(stack, -4);
363 | 			struct val t3 = stack_top_val(stack, -3);
364 | 
365 | 			*(stack->top - 4) = *(stack->top - 2);
366 | 			*(stack->top - 3) = *(stack->top - 1);
367 | 			stack_set_val(stack, -2, t4);
368 | 			stack_set_val(stack, -1, t3);
369 | 		}
370 | 		break;
371 | 
372 | 		case OP_IFDUP:
373 | 		{
374 | 			// (x - 0 | x x)
375 | 			if (stack_size(stack) < 1)
376 | 				SCRIPTERR("INVALID_STACK_OPERATION");
377 | 			struct val v = stack_top_val(stack, -1);
378 | 			if (cast_to_bool(v))
379 | 					stack_push_val(stack, val_copy(v));
380 | 		}
381 | 		break;
382 | 
383 | 		case OP_DEPTH:
384 | 		{
385 | 				// -- stacksize
386 | 			struct num sn;
387 | 			sn_from_int(stack_size(stack), &sn);
388 | 			struct val v = sn_to_val(&sn);
389 | 			stack_push_val(stack, v);
390 | 		}
391 | 		break;
392 | 
393 | 		case OP_DROP:
394 | 		{
395 | 			// (x -- )
396 | 			if (stack_size(stack) < 1)
397 | 				SCRIPTERR("INVALID_STACK_OPERATION");
398 | 			stack_pop(stack);
399 | 		}
400 | 		break;
401 | 
402 | 		case OP_DUP:
403 | 		{
404 | 			// (x -- x x)
405 | 			if (stack_size(stack) < 1)
406 | 				SCRIPTERR("INVALID_STACK_OPERATION");
407 | 			struct val val = stack_top_val(stack, (-1));
408 | 			stack_push_val(stack, val_copy(val));
409 | 		}
410 | 		break;
411 | 
412 | 		case OP_NIP:
413 | 		{
414 | 			// (x1 x2 -- x2)
415 | 			if (stack_size(stack) < 2)
416 | 				SCRIPTERR("INVALID_STACK_OPERATION");
417 | 			// TODO: sanity check - stack_size() == stack_end(stack)
418 | 			stack_set_val(stack, -2, stack_top_val(stack, -1));
419 | 			stack_pop(stack);
420 | 		}
421 | 		break;
422 | 
423 | 		case OP_OVER:
424 | 		{
425 | 			// (x1 x2 -- x1 x2 x1)
426 | 			if (stack_size(stack) < 2)
427 | 				SCRIPTERR("INVALID_STACK_OPERATION");
428 | 			struct val val = stack_top_val(stack, (-2));
429 | 			stack_push_val(stack, val_copy(val));
430 | 		}
431 | 		break;
432 | 
433 | 
434 | 		case OP_PICK:
435 | 		case OP_ROLL:
436 | 		{
437 | 			// (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn)
438 | 			// (xn ... x2 x1 x0 n - ... x2 x1 x0 xn)
439 | 			if (stack_size(stack) < 2)
440 | 					SCRIPTERR("INVALID_STACK_OPERATION");
441 | 			struct num *n;
442 | 
443 | 			enum sn_result res =
444 | 				sn_from_val(stack_top_val(stack, -1), &n);
445 | 
446 | 			if (res != SN_SUCCESS) {
447 | 				sprintf(tmpbuf, "invalid scriptnum %d", res);
448 | 				SCRIPTERR(tmpbuf);
449 | 			}
450 | 
451 | 			stack_pop(stack);
452 | 			if (n->val < 0 || n->val >= (int)stack_size(stack))
453 | 					SCRIPTERR("INVALID_STACK_OPERATION");
454 | 			struct val val = stack_top_val(stack, (-(n->val))-1);
455 | 			if (opcode == OP_ROLL)
456 | 				stack_erase(stack, -(n->val) - 1);
457 | 			stack_push_val(stack, val);
458 | 		}
459 | 		break;
460 | 
461 | 		case OP_ROT:
462 | 		{
463 | 			// (x1 x2 x3 -- x2 x3 x1)
464 | 			//	x2 x1 x3	after first swap
465 | 			//	x2 x3 x1	after second swap
466 | 			if (stack_size(stack) < 3)
467 | 					SCRIPTERR("INVALID_STACK_OPERATION");
468 | 			stack_swap(stack, -3, -2);
469 | 			stack_swap(stack, -2, -1);
470 | 		}
471 | 		break;
472 | 
473 | 		case OP_SWAP:
474 | 		{
475 | 			// (x1 x2 -- x2 x1)
476 | 			if (stack_size(stack) < 2)
477 | 				SCRIPTERR("INVALID_STACK_OPERATION");
478 | 			stack_swap(stack, -2, -1);
479 | 		}
480 | 		break;
481 | 
482 | 		case OP_TUCK:
483 | 		{
484 | 			// (x1 x2 -- x2 x1 x2)
485 | 			if (stack_size(stack) < 2)
486 | 					SCRIPTERR("INVALID_STACK_OPERATION");
487 | 			struct val val = stack_top_val(stack, -1);
488 | 			stack_swap(stack, -2, -1);
489 | 			stack_push_val(stack, val_copy(val));
490 | 		}
491 | 		break;
492 | 
493 | 
494 | 		case OP_SIZE:
495 | 		{
496 | 			// (in -- in size)
497 | 			if (stack_size(stack) < 1)
498 | 					SCRIPTERR("INVALID_STACK_OPERATION");
499 | 			struct val val = stack_top_val(stack, -1);
500 | 			u32 size = val_size(val);
501 | 			val = val_from_int(size);
502 | 			stack_push_val(stack, val);
503 | 		}
504 | 		break;
505 | 
506 | 
507 | 		//
508 | 		// Bitwise logic
509 | 		//
510 | 		case OP_EQUAL:
511 | 		case OP_EQUALVERIFY:
512 | 		//case OP_NOTEQUAL: // use OP_NUMNOTEQUAL
513 | 		{
514 | 			// (x1 x2 - bool)
515 | 			if (stack_size(stack) < 2)
516 | 					SCRIPTERR("INVALID_STACK_OPERATION");
517 | 			struct val v1 = stack_top_val(stack, -2);
518 | 			struct val v2 = stack_top_val(stack, -1);
519 | 			int equal = val_eq(v1, v2);
520 | 			// OP_NOTEQUAL is disabled because it would be too easy to say
521 | 			// something like n != 1 and have some wiseguy pass in 1 with extra
522 | 			// zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001)
523 | 			//if (opcode == OP_NOTEQUAL)
524 | 			//		fEqual = !fEqual;
525 | 			stack_pop(stack);
526 | 			stack_pop(stack);
527 | 			stack_push_val(stack, equal ? val_true : val_false);
528 | 			if (opcode == OP_EQUALVERIFY)
529 | 			{
530 | 					if (equal)
531 | 							stack_pop(stack);
532 | 					else
533 | 							SCRIPTERR("EQUALVERIFY");
534 | 			}
535 | 		}
536 | 		break;
537 | 
538 | 
539 | 		//
540 | 		// Numeric
541 | 		//
542 | 		case OP_1ADD:
543 | 		case OP_1SUB:
544 | 		case OP_NEGATE:
545 | 		case OP_ABS:
546 | 		case OP_NOT:
547 | 		case OP_0NOTEQUAL:
548 | 		{
549 | 			// (in -- out)
550 | 			if (stack_size(stack) < 1)
551 | 					SCRIPTERR("INVALID_STACK_OPERATION");
552 | 			struct num *bn;
553 | 			enum sn_result res =
554 | 				sn_from_val(stack_top_val(stack, -1), &bn);
555 | 
556 | 			if (res != SN_SUCCESS) {
557 | 				sprintf(tmpbuf, "invalid scriptnum %d", res);
558 | 				SCRIPTERR(tmpbuf);
559 | 			}
560 | 
561 | 			switch (opcode)
562 | 			{
563 | 			case OP_1ADD:				bn->val += 1; break;
564 | 			case OP_1SUB:				bn->val -= 1; break;
565 | 			case OP_NEGATE:			bn->val = -bn->val; break;
566 | 			case OP_ABS:
567 | 				if (bn->val < bn_zero.val)
568 | 					bn->val = -(bn->val);
569 | 				break;
570 | 			case OP_NOT:				bn->val = (bn->val == 0); break;
571 | 			case OP_0NOTEQUAL:	bn->val = (bn->val != 0); break;
572 | 			default:						assert(!"invalid opcode"); break;
573 | 			}
574 | 			stack_pop(stack);
575 | 			stack_push_val(stack, sn_to_val(bn));
576 | 		}
577 | 		break;
578 | 
579 | 		case OP_ADD:
580 | 		case OP_SUB:
581 | 		case OP_BOOLAND:
582 | 		case OP_BOOLOR:
583 | 		case OP_NUMEQUAL:
584 | 		case OP_NUMEQUALVERIFY:
585 | 		case OP_NUMNOTEQUAL:
586 | 		case OP_LESSTHAN:
587 | 		case OP_GREATERTHAN:
588 | 		case OP_LESSTHANOREQUAL:
589 | 		case OP_GREATERTHANOREQUAL:
590 | 		case OP_MIN:
591 | 		case OP_MAX:
592 | 		{
593 | 			// (x1 x2 -- out)
594 | 			if (stack_size(stack) < 2)
595 | 					SCRIPTERR("INVALID_STACK_OPERATION");
596 | 			struct num *bn1, *bn2, bn;
597 | 			enum sn_result res;
598 | 			bn.ind = -1;
599 | 			res = sn_from_val(stack_top_val(stack, -2), &bn1);
600 | 			if (res == SN_ERR_OVERFLOWED_INT)
601 | 				SCRIPTERR("SCRIPT_INT_OVERFLOW");
602 | 			res = sn_from_val(stack_top_val(stack, -1), &bn2);
603 | 			if (res == SN_ERR_OVERFLOWED_INT)
604 | 				SCRIPTERR("SCRIPT_INT_OVERFLOW");
605 | 			/* struct num bn(0); */
606 | 			switch (opcode)
607 | 			{
608 | 			case OP_ADD:
609 | 				bn.val = bn1->val + bn2->val;
610 | 				break;
611 | 
612 | 			case OP_SUB:
613 | 				bn.val = bn1->val - bn2->val;
614 | 				break;
615 | 
616 | 			case OP_BOOLAND: bn.val = bn1->val != 0 && bn2->val != 0;
617 | 				break;
618 | 			case OP_BOOLOR:         bn.val = bn1->val != 0 || bn2->val != 0;
619 | 				break;
620 | 			case OP_NUMEQUAL:       bn.val = bn1->val == bn2->val; break;
621 | 			case OP_NUMEQUALVERIFY: bn.val = bn1->val == bn2->val; break;
622 | 			case OP_NUMNOTEQUAL:    bn.val = bn1->val != bn2->val; break;
623 | 			case OP_LESSTHAN:       bn.val = bn1->val < bn2->val; break;
624 | 			case OP_GREATERTHAN:    bn.val = bn1->val > bn2->val; break;
625 | 			case OP_LESSTHANOREQUAL:bn.val = bn1->val <= bn2->val; break;
626 | 			case OP_GREATERTHANOREQUAL:  bn.val = bn1->val >= bn2->val; break;
627 | 			case OP_MIN:
628 | 				bn.val = bn1->val < bn2->val ? bn1->val : bn2->val;
629 | 				break;
630 | 			case OP_MAX:
631 | 				bn.val = bn1->val > bn2->val ? bn1->val : bn2->val;
632 | 				break;
633 | 			default: assert(!"invalid opcode"); break;
634 | 			}
635 | 			stack_pop(stack);
636 | 			stack_pop(stack);
637 | 			struct val bnval = sn_to_val(&bn);
638 | 			stack_push_val(stack, bnval);
639 | 
640 | 			if (opcode == OP_NUMEQUALVERIFY)
641 | 			{
642 | 				if (cast_to_bool(stack_top_val(stack, -1)))
643 | 						stack_pop(stack);
644 | 				else
645 | 						SCRIPTERR("NUMEQUALVERIFY");
646 | 			}
647 | 		}
648 | 		break;
649 | 
650 | 		case OP_WITHIN:
651 | 		{
652 | 			// (x min max -- out)
653 | 			if (stack_size(stack) < 3)
654 | 					SCRIPTERR("INVALID_STACK_OPERATION");
655 | 			struct num *bn1, *bn2, *bn3;
656 | 			sn_from_val(stack_top_val(stack, -3), &bn1);
657 | 			sn_from_val(stack_top_val(stack, -2), &bn2);
658 | 			sn_from_val(stack_top_val(stack, -1), &bn3);
659 | 			int fval = bn2->val <= bn1->val && bn1->val < bn3->val;
660 | 			stack_pop(stack);
661 | 			stack_pop(stack);
662 | 			stack_pop(stack);
663 | 			stack_push_val(stack, fval ? val_true : val_false);
664 | 		}
665 | 		break;
666 | 
667 | 		case OP_RIPEMD160:
668 | 		case OP_SHA1:
669 | 		case OP_SHA256:
670 | 		case OP_HASH160:
671 | 		case OP_HASH256:
672 | 		{
673 | 			// (in -- hash)
674 | 			if (stack_size(stack) < 1)
675 | 				SCRIPTERR("script_err_invalid_stack_operation");
676 | 
677 | 			u16 hashind;
678 | 			u32 valsize;
679 | 			u32 hashlen =
680 | 				(opcode == OP_RIPEMD160 || opcode == OP_SHA1 ||
681 | 				 opcode == OP_HASH160) ? 20 : 32;
682 | 
683 | 			struct val v = stack_top_val(stack, -1);
684 | 
685 | 			val_bytes(v, &valsize, tmpbytes, sizeof(tmpbytes));
686 | 			u8 *hash = byte_pool_new(hashlen, &hashind);
687 | 
688 | 			if (opcode == OP_RIPEMD160) {
689 | 				ripemd160((struct ripemd160*)hash, tmpbytes, valsize);
690 | 			}
691 | 			else if (opcode == OP_SHA256) {
692 | 				sha256((struct sha256*)hash, tmpbytes, valsize);
693 | 			}
694 | 			else if (opcode == OP_HASH160) {
695 | 				sha256((struct sha256*)tmpbytes2, tmpbytes, valsize);
696 | 				ripemd160((struct ripemd160*)hash, tmpbytes2, 32);
697 | 			}
698 | 			else
699 | 				SCRIPTERR("unhandled hash opcode");
700 | 			/*	 cripemd160().write(vch.data(), vch.size()).finalize(vchhash.data()); */
701 | 			/* else if (opcode == op_sha1) */
702 | 			/*	 csha1().write(vch.data(), vch.size()).finalize(vchhash.data()); */
703 | 			/* else if (opcode == op_sha256) */
704 | 			/*	 csha256().write(vch.data(), vch.size()).finalize(vchhash.data()); */
705 | 			/* else if (opcode == op_hash256) */
706 | 			/*	 chash256().write(vch.data(), vch.size()).finalize(vchhash.data()); */
707 | 
708 | 			v.ind = hashind;
709 | 			v.type = VT_RAW;
710 | 
711 | 			stack_pop(stack);
712 | 			stack_push_val(stack, v);
713 | 		}
714 | 		break;
715 | 
716 | 		default: {
717 | 			SCRIPTERR("UNHANDLED_OPCODE");
718 | 		}
719 | 
720 | 		}
721 | 	}
722 | 
723 | 	if (stack_size(ifstack) != 0)
724 | 		SCRIPTERR("UNBALANCED_CONDITIONAL");
725 | 
726 | 
727 | evalerror:
728 | 	result->error = err;
729 | 	result->op_count = c;
730 | 	result->last_op = opcode;
731 | 
732 | 	stack_free(altstack);
733 | 	stack_free(ifstack);
734 | 	return !err;
735 | }
736 | 
737 | 
738 | static char hexchar(unsigned int val)
739 | {
740 | 	if (val < 10)
741 | 		return '0' + val;
742 | 	if (val < 16)
743 | 		return 'a' + val - 10;
744 | 	assert(!"hexchar invalid val");
745 | }
746 | 
747 | static void hex_print(const u8 *buf, size_t bufsize) {
748 | 	for (size_t i = 0; i < bufsize; i++) {
749 | 		unsigned int c = buf[i];
750 | 		printf("%c%c", hexchar(c >> 4), hexchar(c & 0xF) );
751 | 	}
752 | }
753 | 
754 | 
755 | static bool is_push_data(enum opcode op)
756 | {
757 | 	return (op > OP_0 && op < OP_PUSHDATA1) ||
758 | 		op == OP_PUSHDATA1 ||
759 | 		op == OP_PUSHDATA2 ||
760 | 		op == OP_PUSHDATA4;
761 | }
762 | 
763 | void script_print(const u8 *script, size_t script_size, int abbrev_data) {
764 | 	u32 len;
765 | 	static u8 tmpbuf[4096];
766 | 	const u8 *p = script;
767 | 	const u8 *top = script + script_size;
768 | 	bool first = true;
769 | 
770 | 	while (p < top) {
771 | 		enum opcode opcode;
772 | 		script_getop(&p, top, &opcode, tmpbuf, sizeof(tmpbuf), &len);
773 | 
774 | 		if (!first)
775 | 			putchar(' ');
776 | 		first = false;
777 | 
778 | 		if (is_push_data(opcode)) {
779 | 			if (abbrev_data)
780 | 				printf("data(%d)", len);
781 | 			else
782 | 				hex_print(tmpbuf, len);
783 | 		}
784 | 		else
785 | 			printf("%s", op_name(opcode));
786 | 
787 | 		len = 0;
788 | 	}
789 | }
790 | 
791 | void script_print_vals(struct stack *stack) {
792 | 	void **p = stack->bottom;
793 | 	bool first = true;
794 | 	while (p < stack->top) {
795 | 		struct val val;
796 | 		memcpy(&val, &*p++, sizeof(struct val));
797 | 		if (first)
798 | 			first = false;
799 | 		else
800 | 			printf(" ");
801 | 		val_print(val);
802 | 	}
803 | 	putchar('\n');
804 | }
805 | 
806 | void
807 | script_push_int(struct stack *script, s64 intval) {
808 | 	/* u16 len; */
809 | 	/* u16 i; */
810 | 	/* static u8 buf[8]; */
811 | 	struct val val = val_from_int(intval);
812 | 	stack_push_val(script, val);
813 | 	/* val_serialize(val, &len, buf, ARRAY_SIZE(buf)); */
814 | 	/* for (i = 0; i < len; ++i) */
815 | 	/*	 stack_push_small(u8, script, &buf[i]); */
816 | }
817 | 
818 | 
819 | void
820 | script_push_str(struct stack *script, const char *str) {
821 | 	struct val val;
822 | 	u16 ind;
823 | 	u8 *bytes;
824 | 	bytes = byte_pool_new(strlen(str), &ind);
825 | 	strcpy((char*)bytes, str);
826 | 
827 | 	val.type = VT_DATA;
828 | 	val.ind  = ind;
829 | 
830 | 	stack_push_val(script, val);
831 | }
832 | 
833 | void
834 | script_push_datastr(struct stack *script, const char *str, int raw) {
835 | 	int count = 0;
836 | 	u8 *bytes;
837 | 	const char *p = str;
838 | 	u16 ind;
839 | 	u16 nbytes = strlen(str) / 2;
840 | 	struct val val;
841 | 
842 | 	bytes = byte_pool_new(nbytes, &ind);
843 | 
844 | 	/* WARNING: no sanitization or error-checking whatsoever */
845 | 	for(count = 0; count < nbytes; count++) {
846 | 		sscanf(p, "%2hhx", &bytes[count]);
847 | 		p += 2;
848 | 	}
849 | 
850 | 	val.type = raw ? VT_RAW : VT_DATA;
851 | 	val.ind  = ind;
852 | 
853 | 	stack_push_val(script, val);
854 | }
855 | 
856 | 
857 | void
858 | script_push_raw(struct stack *stack, const char *data) {
859 | 	script_push_datastr(stack, data, 1);
860 | }
861 | 
862 | void script_serialize_data(struct val val, u32 *len, u8 *buf) {
863 | 	u8 *p;
864 | 	p = byte_pool_get(val.ind, len);
865 | 	if (*len < OP_PUSHDATA1) {
866 | 		*buf++ = *len;
867 | 		memcpy(buf, p, *len);
868 | 		*len += 1;
869 | 	}
870 | 	else if (*len <= 0xFF) {
871 | 		*buf++ = OP_PUSHDATA1;
872 | 		*buf++ = *len;
873 | 		memcpy(buf, p, *len);
874 | 		*len += 2;
875 | 	}
876 | 	else if (*len <= 0xFFFF) {
877 | 		*buf++ = OP_PUSHDATA2;
878 | 		u16 *sp = (u16*)buf;
879 | 		// TODO: writele16
880 | 		*sp = *len;
881 | 		buf += 2;
882 | 		memcpy(buf, p, *len);
883 | 		*len += 3;
884 | 	}
885 | 	else {
886 | 		*buf++ = OP_PUSHDATA4;
887 | 		u32 *ip = (u32*)buf;
888 | 		// TODO: writele32
889 | 		*ip = *len;
890 | 		buf += 4;
891 | 		memcpy(buf, p, *len);
892 | 		*len += 5;
893 | 	}
894 | 	return;
895 | }
896 | 
897 | void script_serialize(struct stack *stack, u8 *buf, int buflen, int* len)
898 | {
899 | 	struct val *valp;
900 | 	void **sp;
901 | 	u8 *p = buf;
902 | 	u32 valsize = 0;
903 | 	*len = 0;
904 | 	sp = stack->bottom;
905 | 
906 | 	while (sp < stack->top) {
907 | 		/* printf("%02x %02x %02x %02x | ", huh[0], huh[1], huh[2], huh[3]); */
908 | 		/* printf("%d %d\n", val.type, val.ind); */
909 | 		valp = (struct val*)sp;
910 | 
911 | 		switch (valp->type) {
912 | 		case VT_SCRIPTNUM: {
913 | 			struct num *sn = num_pool_get(valp->ind);
914 | 
915 | 			if (sn->val == -1) {
916 | 				valsize = 1;
917 | 				*p = OP_1NEGATE;
918 | 			}
919 | 			else if (sn->val == 0 ) {
920 | 				valsize = 1;
921 | 				*p = 0;
922 | 			}
923 | 			else if (sn->val >= 1 && sn->val <= 16 ) {
924 | 				valsize = 1;
925 | 				*p = OP_1 - 1 + sn->val;
926 | 			}
927 | 			else {
928 | 				val_serialize(*valp, &valsize, p+1, buflen-((p+1)-buf));
929 | 				*p = (u8)valsize;
930 | 				valsize++;
931 | 			}
932 | 			break;
933 | 		}
934 | 		case VT_DATA:
935 | 			script_serialize_data(*valp, &valsize, p);
936 | 			break;
937 | 		default:
938 | 			val_serialize(*valp, &valsize, p, buflen-(p-buf));
939 | 		}
940 | 
941 | 		p += valsize;
942 | 		*len += valsize;
943 | 		assert(p-buf <= buflen);
944 | 		sp++;
945 | 	}
946 | 
947 | }
948 | 
949 | void stack_serialize(struct stack *stack, u8 *buf, int buflen, int *len) {
950 | 	struct val *valp;
951 | 	void **sp;
952 | 	u8 *p = buf;
953 | 	u32 valsize;
954 | 	*len = 0;
955 | 	sp = stack->bottom;
956 | 
957 | 	while (sp < stack->top) {
958 | 		/* printf("%02x %02x %02x %02x | ", huh[0], huh[1], huh[2], huh[3]); */
959 | 		/* printf("%d %d\n", val.type, val.ind); */
960 | 		valp = (struct val*)sp;
961 | 
962 | 		val_serialize(*valp, &valsize, p, buflen-(p-buf));
963 | 
964 | 		p += valsize;
965 | 		*len += valsize;
966 | 		assert(p-buf <= buflen);
967 | 		sp++;
968 | 	}
969 | }
970 | 
971 | void
972 | script_handle_input(struct stack *stack UNUSED, const char *str UNUSED) {
973 | }
974 | 


--------------------------------------------------------------------------------