int main(void) { setup_locale(); struct privkey privkey; struct secret base_secret, per_commitment_secret; struct pubkey base_point, per_commitment_point, pubkey, pubkey2; setup_tmpctx(); secp256k1_ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN); base_secret = secret_from_hex("0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"); per_commitment_secret = secret_from_hex("0x1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100"); printf("base_secret: 0x%s\n", tal_hexstr(tmpctx, &base_secret, sizeof(base_secret))); printf("per_commitment_secret: 0x%s\n", tal_hexstr(tmpctx, &per_commitment_secret, sizeof(per_commitment_secret))); if (!secp256k1_ec_pubkey_create(secp256k1_ctx, &per_commitment_point.pubkey, per_commitment_secret.data)) abort(); if (!secp256k1_ec_pubkey_create(secp256k1_ctx, &base_point.pubkey, base_secret.data)) abort(); printf("base_point: 0x%s\n", type_to_string(tmpctx, struct pubkey, &base_point)); printf("per_commitment_point: 0x%s\n", type_to_string(tmpctx, struct pubkey, &per_commitment_point)); /* FIXME: Annotate internal steps. */ if (!derive_simple_key(&base_point, &per_commitment_point, &pubkey)) abort(); printf("localkey: 0x%s\n", type_to_string(tmpctx, struct pubkey, &pubkey)); if (!derive_simple_privkey(&base_secret, &base_point, &per_commitment_point, &privkey)) abort(); printf("localprivkey: 0x%s\n", tal_hexstr(tmpctx, &privkey, sizeof(privkey))); pubkey_from_privkey(&privkey, &pubkey2); assert(pubkey_eq(&pubkey, &pubkey2)); /* FIXME: Annotate internal steps. */ if (!derive_revocation_key(&base_point, &per_commitment_point, &pubkey)) abort(); printf("revocationkey: 0x%s\n", type_to_string(tmpctx, struct pubkey, &pubkey)); if (!derive_revocation_privkey(&base_secret, &per_commitment_secret, &base_point, &per_commitment_point, &privkey)) abort(); printf("revocationprivkey: 0x%s\n", tal_hexstr(tmpctx, &privkey, sizeof(privkey))); pubkey_from_privkey(&privkey, &pubkey2); assert(pubkey_eq(&pubkey, &pubkey2)); /* No memory leaks please */ secp256k1_context_destroy(secp256k1_ctx); tal_free(tmpctx); return 0; }
#include "ecc_k1_projects_basics.h" void Espace(void) /* waits until SPACE key is pressed.*/ /* in borland does not work in win32s programs ????*/ { printf("\nPress Space : "); #ifdef _MSC_VER // while(getch()!=32);//This POSIX function is deprecated. Use the ISO C++ conformant _getch instead. while(_getch()!=32); #else while(getchar()!=32); #endif printf("continuing.\n"); } #undef ASSERT static secp256k1_context_t *ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY); void BitcoinECCgetPubkey_secp256k1(unsigned char *Here64x,unsigned char *Secret){ unsigned char privkey[32]; unsigned char pubkeyc[65]; int pubkeyclen = 65; secp256k1_pubkey_t pubkey; unsigned char digest[SHA256_DIGEST_LENGTH]; unsigned char digest2[20]; //secp256k1_ec_seckey_verify(ctx,Secret); secp256k1_ec_pubkey_create(ctx, &pubkey, Secret); secp256k1_ec_pubkey_serialize(ctx, pubkeyc, &pubkeyclen, &pubkey, 0); SHA256((unsigned char*)pubkeyc, pubkeyclen, digest);
int main(int argc, char *argv[]) { struct io_conn *conn = tal(NULL, struct io_conn); struct wireaddr_internal addr; int af = -1; struct pubkey us, them; const char *err_msg; const char *at; struct addrinfo *ai = NULL; setup_locale(); secp256k1_ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN); opt_register_noarg("--initial-sync", opt_set_bool, &initial_sync, "Stream complete gossip history at start"); opt_register_arg("--max-messages", opt_set_ulongval, opt_show_ulongval, &max_messages, "Terminate after reading this many messages (> 0)"); opt_register_noarg("--stdin", opt_set_bool, &stream_stdin, "Stream gossip messages from stdin."); opt_register_noarg("--help|-h", opt_usage_and_exit, "id@addr[:port] [hex-msg-tosend...]\n" "Connect to a lightning peer and relay gossip messages from it", "Print this message."); opt_parse(&argc, argv, opt_log_stderr_exit); if (argc < 2) opt_usage_exit_fail("Need an id@addr to connect to"); at = strchr(argv[1], '@'); if (!at) opt_usage_exit_fail("Need id@addr"); if (!pubkey_from_hexstr(argv[1], at - argv[1], &them)) opt_usage_exit_fail("Invalid id %.*s", (int)(at - argv[1]), argv[1]); if (!parse_wireaddr_internal(at+1, &addr, DEFAULT_PORT, NULL, true, false, &err_msg)) opt_usage_exit_fail("%s '%s'", err_msg, argv[1]); switch (addr.itype) { case ADDR_INTERNAL_SOCKNAME: af = AF_LOCAL; ai = wireaddr_internal_to_addrinfo(conn, &addr); break; case ADDR_INTERNAL_ALLPROTO: case ADDR_INTERNAL_AUTOTOR: case ADDR_INTERNAL_FORPROXY: opt_usage_exit_fail("Don't support proxy use"); case ADDR_INTERNAL_WIREADDR: switch (addr.u.wireaddr.type) { case ADDR_TYPE_TOR_V2: case ADDR_TYPE_TOR_V3: opt_usage_exit_fail("Don't support proxy use"); break; case ADDR_TYPE_IPV4: af = AF_INET; break; case ADDR_TYPE_IPV6: af = AF_INET6; break; } ai = wireaddr_to_addrinfo(tmpctx, &addr.u.wireaddr); } if (af == -1 || ai == NULL) err(1, "Initializing socket"); conn->fd = socket(af, SOCK_STREAM, 0); if (conn->fd < 0) err(1, "Creating socket"); memset(¬sosecret, 0x42, sizeof(notsosecret)); if (!pubkey_from_secret(¬sosecret, &us)) errx(1, "Creating pubkey"); if (connect(conn->fd, ai->ai_addr, ai->ai_addrlen) != 0) err(1, "Connecting to %s", at+1); initiator_handshake(conn, &us, &them, &addr, handshake_success, argv+2); exit(0); }
secp256k1_context * Secp256k1ContextFactory::makeNew(int flags) const { return secp256k1_context_create(flags); }
int main(int argc, char **argv) { bench_data data; int i, p; secp256k1_gej* pubkeys_gej; size_t scratch_size; if (argc > 1) { if(have_flag(argc, argv, "pippenger_wnaf")) { printf("Using pippenger_wnaf:\n"); data.ecmult_multi = secp256k1_ecmult_pippenger_batch_single; } else if(have_flag(argc, argv, "strauss_wnaf")) { printf("Using strauss_wnaf:\n"); data.ecmult_multi = secp256k1_ecmult_strauss_batch_single; } } else { data.ecmult_multi = secp256k1_ecmult_multi_var; } /* Allocate stuff */ data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY); scratch_size = secp256k1_strauss_scratch_size(POINTS) + STRAUSS_SCRATCH_OBJECTS*16; data.scratch = secp256k1_scratch_space_create(data.ctx, scratch_size); data.scalars = malloc(sizeof(secp256k1_scalar) * POINTS); data.seckeys = malloc(sizeof(secp256k1_scalar) * POINTS); data.pubkeys = malloc(sizeof(secp256k1_ge) * POINTS); data.expected_output = malloc(sizeof(secp256k1_gej) * (ITERS + 1)); data.output = malloc(sizeof(secp256k1_gej) * (ITERS + 1)); /* Generate a set of scalars, and private/public keypairs. */ pubkeys_gej = malloc(sizeof(secp256k1_gej) * POINTS); secp256k1_gej_set_ge(&pubkeys_gej[0], &secp256k1_ge_const_g); secp256k1_scalar_set_int(&data.seckeys[0], 1); for (i = 0; i < POINTS; ++i) { generate_scalar(i, &data.scalars[i]); if (i) { secp256k1_gej_double_var(&pubkeys_gej[i], &pubkeys_gej[i - 1], NULL); secp256k1_scalar_add(&data.seckeys[i], &data.seckeys[i - 1], &data.seckeys[i - 1]); } } secp256k1_ge_set_all_gej_var(data.pubkeys, pubkeys_gej, POINTS); free(pubkeys_gej); for (i = 1; i <= 8; ++i) { run_test(&data, i, 1); } for (p = 0; p <= 11; ++p) { for (i = 9; i <= 16; ++i) { run_test(&data, i << p, 1); } } secp256k1_context_destroy(data.ctx); secp256k1_scratch_space_destroy(data.scratch); free(data.scalars); free(data.pubkeys); free(data.seckeys); free(data.output); free(data.expected_output); return(0); }