retkey = NULL;
for (key_index = 0; key_index < key->nkeys; key_index++) {
- unsigned char *thiskey;
+ const unsigned char *thiskey;
int thiskeylen;
/*
goto error;
}
- thiskey = (unsigned char *)priv;
+ thiskey = priv;
/*
* Skip over the pieces of key.
return pkt->body + (pkt->savedpos - length);
}
static int ssh1_pkt_getrsakey(struct Packet *pkt, struct RSAKey *key,
- unsigned char **keystr)
+ const unsigned char **keystr)
{
int j;
struct do_ssh1_login_state {
int crLine;
int len;
- unsigned char *rsabuf, *keystr1, *keystr2;
+ unsigned char *rsabuf;
+ const unsigned char *keystr1, *keystr2;
unsigned long supported_ciphers_mask, supported_auths_mask;
int tried_publickey, tried_agent;
int tis_auth_refused, ccard_auth_refused;
Bignum privateKey;
};
-int makekey(unsigned char *data, int len, struct RSAKey *result,
- unsigned char **keystr, int order);
-int makeprivate(unsigned char *data, int len, struct RSAKey *result);
+int makekey(const unsigned char *data, int len, struct RSAKey *result,
+ const unsigned char **keystr, int order);
+int makeprivate(const unsigned char *data, int len, struct RSAKey *result);
int rsaencrypt(unsigned char *data, int length, struct RSAKey *key);
Bignum rsadecrypt(Bignum input, struct RSAKey *key);
void rsasign(unsigned char *data, int length, struct RSAKey *key);
};
struct ssh_signkey {
- void *(*newkey) (char *data, int len);
+ void *(*newkey) (const char *data, int len);
void (*freekey) (void *key);
char *(*fmtkey) (void *key);
unsigned char *(*public_blob) (void *key, int *len);
unsigned char *(*private_blob) (void *key, int *len);
- void *(*createkey) (unsigned char *pub_blob, int pub_len,
- unsigned char *priv_blob, int priv_len);
- void *(*openssh_createkey) (unsigned char **blob, int *len);
+ void *(*createkey) (const unsigned char *pub_blob, int pub_len,
+ const unsigned char *priv_blob, int priv_len);
+ void *(*openssh_createkey) (const unsigned char **blob, int *len);
int (*openssh_fmtkey) (void *key, unsigned char *blob, int len);
/* OpenSSH private key blobs, as created by openssh_fmtkey and
* consumed by openssh_createkey, always (at least so far...) take
* skip over the right number to find the next key in the file.
* openssh_private_npieces gives that information. */
int openssh_private_npieces;
- int (*pubkey_bits) (void *blob, int len);
+ int (*pubkey_bits) (const void *blob, int len);
char *(*fingerprint) (void *key);
- int (*verifysig) (void *key, char *sig, int siglen,
- char *data, int datalen);
- unsigned char *(*sign) (void *key, char *data, int datalen,
+ int (*verifysig) (void *key, const char *sig, int siglen,
+ const char *data, int datalen);
+ unsigned char *(*sign) (void *key, const char *data, int datalen,
int *siglen);
char *name;
char *keytype; /* for host key cache */
smemclr(lenbuf, sizeof(lenbuf));
}
-static void getstring(char **data, int *datalen, char **p, int *length)
+static void getstring(const char **data, int *datalen,
+ const char **p, int *length)
{
*p = NULL;
if (*datalen < 4)
*data += *length;
*datalen -= *length;
}
-static Bignum getmp(char **data, int *datalen)
+static Bignum getmp(const char **data, int *datalen)
{
- char *p;
+ const char *p;
int length;
Bignum b;
return NULL;
if (p[0] & 0x80)
return NULL; /* negative mp */
- b = bignum_from_bytes((unsigned char *)p, length);
+ b = bignum_from_bytes((const unsigned char *)p, length);
return b;
}
-static Bignum get160(char **data, int *datalen)
+static Bignum get160(const char **data, int *datalen)
{
Bignum b;
if (*datalen < 20)
return NULL;
- b = bignum_from_bytes((unsigned char *)*data, 20);
+ b = bignum_from_bytes((const unsigned char *)*data, 20);
*data += 20;
*datalen -= 20;
static void dss_freekey(void *key); /* forward reference */
-static void *dss_newkey(char *data, int len)
+static void *dss_newkey(const char *data, int len)
{
- char *p;
+ const char *p;
int slen;
struct dss_key *dss;
return ret;
}
-static int dss_verifysig(void *key, char *sig, int siglen,
- char *data, int datalen)
+static int dss_verifysig(void *key, const char *sig, int siglen,
+ const char *data, int datalen)
{
struct dss_key *dss = (struct dss_key *) key;
- char *p;
+ const char *p;
int slen;
char hash[20];
Bignum r, s, w, gu1p, yu2p, gu1yu2p, u1, u2, sha, v;
return blob;
}
-static void *dss_createkey(unsigned char *pub_blob, int pub_len,
- unsigned char *priv_blob, int priv_len)
+static void *dss_createkey(const unsigned char *pub_blob, int pub_len,
+ const unsigned char *priv_blob, int priv_len)
{
struct dss_key *dss;
- char *pb = (char *) priv_blob;
- char *hash;
+ const char *pb = (const char *) priv_blob;
+ const char *hash;
int hashlen;
SHA_State s;
unsigned char digest[20];
return dss;
}
-static void *dss_openssh_createkey(unsigned char **blob, int *len)
+static void *dss_openssh_createkey(const unsigned char **blob, int *len)
{
- char **b = (char **) blob;
+ const char **b = (const char **) blob;
struct dss_key *dss;
dss = snew(struct dss_key);
return bloblen;
}
-static int dss_pubkey_bits(void *blob, int len)
+static int dss_pubkey_bits(const void *blob, int len)
{
struct dss_key *dss;
int ret;
- dss = dss_newkey((char *) blob, len);
+ dss = dss_newkey((const char *) blob, len);
if (!dss)
return -1;
ret = bignum_bitcount(dss->p);
}
}
-static unsigned char *dss_sign(void *key, char *data, int datalen, int *siglen)
+static unsigned char *dss_sign(void *key, const char *data, int datalen,
+ int *siglen)
{
struct dss_key *dss = (struct dss_key *) key;
Bignum k, gkp, hash, kinv, hxr, r, s;
return &curve;
}
-static struct ec_curve *ec_name_to_curve(char *name, int len) {
+static struct ec_curve *ec_name_to_curve(const char *name, int len) {
if (len == 8 && !memcmp(name, "nistp", 5)) {
name += 5;
if (!memcmp(name, "256", 3)) {
* Misc functions
*/
-static void getstring(char **data, int *datalen, char **p, int *length)
+static void getstring(const char **data, int *datalen,
+ const char **p, int *length)
{
*p = NULL;
if (*datalen < 4)
*datalen -= *length;
}
-static Bignum getmp(char **data, int *datalen)
+static Bignum getmp(const char **data, int *datalen)
{
- char *p;
+ const char *p;
int length;
getstring(data, datalen, &p, &length);
return bignum_from_bytes((unsigned char *)p, length);
}
-static int decodepoint(char *p, int length, struct ec_point *point)
+static int decodepoint(const char *p, int length, struct ec_point *point)
{
if (length < 1 || p[0] != 0x04) /* Only support uncompressed point */
return 0;
return 1;
}
-static int getmppoint(char **data, int *datalen, struct ec_point *point)
+static int getmppoint(const char **data, int *datalen, struct ec_point *point)
{
- char *p;
+ const char *p;
int length;
getstring(data, datalen, &p, &length);
sfree(ec);
}
-static void *ecdsa_newkey(char *data, int len)
+static void *ecdsa_newkey(const char *data, int len)
{
- char *p;
+ const char *p;
int slen;
struct ec_key *ec;
struct ec_curve *curve;
return blob;
}
-static void *ecdsa_createkey(unsigned char *pub_blob, int pub_len,
- unsigned char *priv_blob, int priv_len)
+static void *ecdsa_createkey(const unsigned char *pub_blob, int pub_len,
+ const unsigned char *priv_blob, int priv_len)
{
struct ec_key *ec;
struct ec_point *publicKey;
- char *pb = (char *) priv_blob;
+ const char *pb = (const char *) priv_blob;
- ec = (struct ec_key*)ecdsa_newkey((char *) pub_blob, pub_len);
+ ec = (struct ec_key*)ecdsa_newkey((const char *) pub_blob, pub_len);
if (!ec) {
return NULL;
}
return ec;
}
-static void *ecdsa_openssh_createkey(unsigned char **blob, int *len)
+static void *ecdsa_openssh_createkey(const unsigned char **blob, int *len)
{
- char **b = (char **) blob;
- char *p;
+ const char **b = (const char **) blob;
+ const char *p;
int slen;
struct ec_key *ec;
struct ec_curve *curve;
return bloblen;
}
-static int ecdsa_pubkey_bits(void *blob, int len)
+static int ecdsa_pubkey_bits(const void *blob, int len)
{
struct ec_key *ec;
int ret;
- ec = (struct ec_key*)ecdsa_newkey((char *) blob, len);
+ ec = (struct ec_key*)ecdsa_newkey((const char *) blob, len);
if (!ec)
return -1;
ret = ec->publicKey.curve->fieldBits;
return ret;
}
-static int ecdsa_verifysig(void *key, char *sig, int siglen,
- char *data, int datalen)
+static int ecdsa_verifysig(void *key, const char *sig, int siglen,
+ const char *data, int datalen)
{
struct ec_key *ec = (struct ec_key *) key;
- char *p;
+ const char *p;
int slen;
unsigned char digest[512 / 8];
int digestLen;
return ret;
}
-static unsigned char *ecdsa_sign(void *key, char *data, int datalen,
+static unsigned char *ecdsa_sign(void *key, const char *data, int datalen,
int *siglen)
{
struct ec_key *ec = (struct ec_key *) key;
#include "ssh.h"
#include "misc.h"
-int makekey(unsigned char *data, int len, struct RSAKey *result,
- unsigned char **keystr, int order)
+int makekey(const unsigned char *data, int len, struct RSAKey *result,
+ const unsigned char **keystr, int order)
{
- unsigned char *p = data;
+ const unsigned char *p = data;
int i, n;
if (len < 4)
return p - data;
}
-int makeprivate(unsigned char *data, int len, struct RSAKey *result)
+int makeprivate(const unsigned char *data, int len, struct RSAKey *result)
{
return ssh1_read_bignum(data, len, &result->private_exponent);
}
* Implementation of the ssh-rsa signing key type.
*/
-static void getstring(char **data, int *datalen, char **p, int *length)
+static void getstring(const char **data, int *datalen,
+ const char **p, int *length)
{
*p = NULL;
if (*datalen < 4)
*data += *length;
*datalen -= *length;
}
-static Bignum getmp(char **data, int *datalen)
+static Bignum getmp(const char **data, int *datalen)
{
- char *p;
+ const char *p;
int length;
Bignum b;
static void rsa2_freekey(void *key); /* forward reference */
-static void *rsa2_newkey(char *data, int len)
+static void *rsa2_newkey(const char *data, int len)
{
- char *p;
+ const char *p;
int slen;
struct RSAKey *rsa;
return blob;
}
-static void *rsa2_createkey(unsigned char *pub_blob, int pub_len,
- unsigned char *priv_blob, int priv_len)
+static void *rsa2_createkey(const unsigned char *pub_blob, int pub_len,
+ const unsigned char *priv_blob, int priv_len)
{
struct RSAKey *rsa;
- char *pb = (char *) priv_blob;
+ const char *pb = (const char *) priv_blob;
rsa = rsa2_newkey((char *) pub_blob, pub_len);
rsa->private_exponent = getmp(&pb, &priv_len);
return rsa;
}
-static void *rsa2_openssh_createkey(unsigned char **blob, int *len)
+static void *rsa2_openssh_createkey(const unsigned char **blob, int *len)
{
- char **b = (char **) blob;
+ const char **b = (const char **) blob;
struct RSAKey *rsa;
rsa = snew(struct RSAKey);
return bloblen;
}
-static int rsa2_pubkey_bits(void *blob, int len)
+static int rsa2_pubkey_bits(const void *blob, int len)
{
struct RSAKey *rsa;
int ret;
- rsa = rsa2_newkey((char *) blob, len);
+ rsa = rsa2_newkey((const char *) blob, len);
ret = bignum_bitcount(rsa->modulus);
rsa2_freekey(rsa);
#define ASN1_LEN ( (int) sizeof(asn1_weird_stuff) )
-static int rsa2_verifysig(void *key, char *sig, int siglen,
- char *data, int datalen)
+static int rsa2_verifysig(void *key, const char *sig, int siglen,
+ const char *data, int datalen)
{
struct RSAKey *rsa = (struct RSAKey *) key;
Bignum in, out;
- char *p;
+ const char *p;
int slen;
int bytes, i, j, ret;
unsigned char hash[20];
return ret;
}
-static unsigned char *rsa2_sign(void *key, char *data, int datalen,
+static unsigned char *rsa2_sign(void *key, const char *data, int datalen,
int *siglen)
{
struct RSAKey *rsa = (struct RSAKey *) key;