double do_atanh(double x)
{
double z;
z = do_sign(0.5, x);
x = do_sign(x, 1.0);
x = x / (1.0 - x);
return (z * LOG1P(x + x));
}
double do_asinh(double x)
{
double s, t;
if (1.0 + x * x == 1.0)
return (x);
if (sqrt(1.0 + x * x) == 1.0)
return (do_sign(1.0, x) * (LOG1P(x) + log(2.0)));
else
{
t = fabs(x);
s = 1.0 / t;
return (do_sign(1.0, x) * LOG1P(t + t / (s + sqrt(1 + s * s))));
}
}
static void cert_password_dialog(void)
{
int is;
ui_dialog_begin(400, (ui.gridsize+4)*3);
{
ui_layout(T, X, NW, 2, 2);
ui_label("Password:"******"Cancel"))
ui.dialog = NULL;
ui_spacer();
if (ui_button("Okay") || is == UI_INPUT_ACCEPT)
{
ui.dialog = NULL;
do_sign();
}
}
ui_panel_end();
}
ui_dialog_end();
}
int gidit_pushobj(FILE *fp, char * signingkey, int sign, unsigned int flags)
{
const char *head;
unsigned char head_sha1[21];
struct gidit_refs_cb_data cbdata;
struct strbuf buf = STRBUF_INIT;
cbdata.buf = &buf;
cbdata.flags = flags;
head = resolve_ref("HEAD", head_sha1, 0, NULL);
head_sha1[20] = '\0';
if (!head) {
strbuf_release(&buf);
return error("Failed to resolve HEAD as a valid ref.");
}
strbuf_add(&buf, sha1_to_hex(head_sha1), 40);
strbuf_addstr(&buf, " HEAD\n");
for_each_ref(resolve_one_ref, &cbdata);
if (sign)
do_sign(&buf, signingkey);
if (fwrite(buf.buf, buf.len, 1, fp) != 1) {
strbuf_release(&buf);
return error("Error while writing pushobj");
}
strbuf_release(&buf);
return 0;
}
static int build_tag_object(struct strbuf *buf, int sign, unsigned char *result)
{
if (sign && do_sign(buf) < 0)
return error(_("unable to sign the tag"));
if (write_sha1_file(buf->buf, buf->len, tag_type, result) < 0)
return error(_("unable to write tag file"));
return 0;
}
static void test_rsa_sign(void)
{
ptls_openssl_sign_certificate_t *sc = (ptls_openssl_sign_certificate_t *)ctx->sign_certificate;
const void *message = "hello world";
ptls_buffer_t sigbuf;
uint8_t sigbuf_small[1024];
ptls_buffer_init(&sigbuf, sigbuf_small, sizeof(sigbuf_small));
ok(do_sign(sc->key, &sigbuf, ptls_iovec_init(message, strlen(message)), EVP_sha256()) == 0);
EVP_PKEY_up_ref(sc->key);
ok(verify_sign(sc->key, ptls_iovec_init(message, strlen(message)), ptls_iovec_init(sigbuf.base, sigbuf.off)) == 0);
ptls_buffer_dispose(&sigbuf);
}
static void test_ecdsa_sign(void)
{
EVP_PKEY *pkey;
{ /* create pkey */
EC_KEY *eckey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
EC_KEY_generate_key(eckey);
pkey = EVP_PKEY_new();
EVP_PKEY_set1_EC_KEY(pkey, eckey);
EC_KEY_free(eckey);
}
const char *message = "hello world";
ptls_buffer_t sigbuf;
uint8_t sigbuf_small[1024];
ptls_buffer_init(&sigbuf, sigbuf_small, sizeof(sigbuf_small));
ok(do_sign(pkey, &sigbuf, ptls_iovec_init(message, strlen(message)), EVP_sha256()) == 0);
EVP_PKEY_up_ref(pkey);
ok(verify_sign(pkey, ptls_iovec_init(message, strlen(message)), ptls_iovec_init(sigbuf.base, sigbuf.off)) == 0);
ptls_buffer_dispose(&sigbuf);
EVP_PKEY_free(pkey);
}
int kex_dhinit(session *s, ssh_packet *p) {
char buf[MAX_SSH_PAYLOAD_SIZE], *t;
uint32 pos = 0, bytes;
byte *sign, *KS;
void *packet;
kexinit_packet *cl = (kexinit_packet *)s->kex;
mpint *pub_key;
unsigned int want_keylen;
char *err;
want_keylen = (unsigned int)crypto_cipher_key_size(s->e_s2c);
s->secret_key = crypto_kex(s->kex_algo, p->data, &pub_key, want_keylen, &err);
if (!s->secret_key) {
/** XXX: free secret_key & dh_pub_key on cleanup - register crypto_cleanup() */
kex_cleanup(s);
DEBUG("KEX gen failed - %s (%d-%d-%d)", err, DH1, DH14, s->kex_algo);
return 0;
}
/* compute H = HASH(V_C || V_S || I_C || I_S || K_S || e || f || K) */
/* string VC */
t = make_string(s->client_version, &bytes);
memcpy(buf+pos, t, bytes);
FREE(t);
pos += bytes;
/* string VS */
t = make_string(SSH_IDENT, &bytes);
memcpy(buf+pos, t, bytes);
FREE(t);
pos += bytes;
/* string IC */
t = make_string_b(cl->IC, cl->IC_len, &bytes);
memcpy(buf+pos, t, bytes);
FREE(t);
pos += bytes;
/* string IS */
//show_hex(cl->IS, cl->IS_len);
t = make_string_b(cl->IS, cl->IS_len, &bytes);
memcpy(buf+pos, t, bytes);
FREE(t);
pos += bytes;
/* string KS */
t = KS = make_ssh_key(s->host_key, s->server_ctx->dsa_keys, &bytes);
KS = make_string_b(KS, bytes, &bytes);
FREE(t);
memcpy(buf+pos, KS, bytes);
pos += bytes;
/* mpint e */
bytes = long_swap(*(uint32 *)p->data) + sizeof(uint32);
memcpy(buf+pos, p->data, bytes);
pos += bytes;
/* mpint f */
bytes = long_swap(*(uint32 *)pub_key) + sizeof(uint32);
memcpy(buf+pos, pub_key, bytes);
pos += bytes;
/* mpint K */
bytes = long_swap(*(uint32 *)s->secret_key) + sizeof(uint32);
memcpy(buf+pos, s->secret_key, bytes);
pos += bytes;
t = crypto_hash(SHA1, buf, &pos, &err);
if (!s->enc) {
s->session_id = MALLOC(20);
memcpy(s->session_id, t, 20);
}
cl->kex_hash = t;
/* sign the hash with our host private key */
bytes = 20;
sign = do_sign(s->host_key, t, &bytes, s, &err);
t = sign;
sign = make_string_b(sign, bytes, &bytes);
FREE(t);
plain_ssh_packet_begin(&packet, SSH_MSG_KEXDH_REPLY);
plain_ssh_packet_add_string(packet, KS);
plain_ssh_packet_add_mpint(packet, pub_key);
plain_ssh_packet_add_string(packet, sign);
plain_ssh_packet_finalize(s, packet);
FREE(sign);
FREE(KS);
FREE(pub_key);
if (!plain_ssh_packet_write(s, packet)) {
kex_cleanup(s);
DEBUG("failed to write KEXDH_REPLY");
return 0;
}
return 1;
}
