[u/mdw/putty] / ssh.h

#include <stdio.h>
#include <string.h>

#include "puttymem.h"
#include "network.h"
#include "int64.h"
#include "misc.h"

struct ssh_channel;

extern void sshfwd_close(struct ssh_channel *c);
extern int sshfwd_write(struct ssh_channel *c, char *, int);
extern void sshfwd_unthrottle(struct ssh_channel *c, int bufsize);

/*
 * Useful thing.
 */
#ifndef lenof
#define lenof(x) ( (sizeof((x))) / (sizeof(*(x))))
#endif

#define SSH_CIPHER_IDEA		1
#define SSH_CIPHER_DES		2
#define SSH_CIPHER_3DES		3
#define SSH_CIPHER_BLOWFISH	6

#ifdef MSCRYPTOAPI
#define APIEXTRA 8
#else
#define APIEXTRA 0
#endif

#ifndef BIGNUM_INTERNAL
typedef void *Bignum;
#endif

struct RSAKey {
    int bits;
    int bytes;
#ifdef MSCRYPTOAPI
    unsigned long exponent;
    unsigned char *modulus;
#else
    Bignum modulus;
    Bignum exponent;
    Bignum private_exponent;
    Bignum p;
    Bignum q;
    Bignum iqmp;
#endif
    char *comment;
};

struct dss_key {
    Bignum p, q, g, y, x;
};

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 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);
void rsasanitise(struct RSAKey *key);
int rsastr_len(struct RSAKey *key);
void rsastr_fmt(char *str, struct RSAKey *key);
void rsa_fingerprint(char *str, int len, struct RSAKey *key);
int rsa_verify(struct RSAKey *key);
unsigned char *rsa_public_blob(struct RSAKey *key, int *len);
int rsa_public_blob_len(void *data, int maxlen);
void freersakey(struct RSAKey *key);

typedef unsigned int word32;
typedef unsigned int uint32;

unsigned long crc32_compute(const void *s, size_t len);
unsigned long crc32_update(unsigned long crc_input, const void *s, size_t len);

/* SSH CRC compensation attack detector */
void *crcda_make_context(void);
void crcda_free_context(void *handle);
int detect_attack(void *handle, unsigned char *buf, uint32 len,
		  unsigned char *IV);

/*
 * SSH2 RSA key exchange functions
 */
struct ssh_hash;
void *ssh_rsakex_newkey(char *data, int len);
void ssh_rsakex_freekey(void *key);
int ssh_rsakex_klen(void *key);
void ssh_rsakex_encrypt(const struct ssh_hash *h, unsigned char *in, int inlen,
                        unsigned char *out, int outlen,
                        void *key);

typedef struct {
    uint32 h[4];
} MD5_Core_State;

struct MD5Context {
#ifdef MSCRYPTOAPI
    unsigned long hHash;
#else
    MD5_Core_State core;
    unsigned char block[64];
    int blkused;
    uint32 lenhi, lenlo;
#endif
};

void MD5Init(struct MD5Context *context);
void MD5Update(struct MD5Context *context, unsigned char const *buf,
	       unsigned len);
void MD5Final(unsigned char digest[16], struct MD5Context *context);
void MD5Simple(void const *p, unsigned len, unsigned char output[16]);

void *hmacmd5_make_context(void);
void hmacmd5_free_context(void *handle);
void hmacmd5_key(void *handle, void const *key, int len);
void hmacmd5_do_hmac(void *handle, unsigned char const *blk, int len,
		     unsigned char *hmac);

typedef struct {
    uint32 h[5];
    unsigned char block[64];
    int blkused;
    uint32 lenhi, lenlo;
} SHA_State;
void SHA_Init(SHA_State * s);
void SHA_Bytes(SHA_State * s, void *p, int len);
void SHA_Final(SHA_State * s, unsigned char *output);
void SHA_Simple(void *p, int len, unsigned char *output);

void hmac_sha1_simple(void *key, int keylen, void *data, int datalen,
		      unsigned char *output);
typedef struct {
    uint32 h[8];
    unsigned char block[64];
    int blkused;
    uint32 lenhi, lenlo;
} SHA256_State;
void SHA256_Init(SHA256_State * s);
void SHA256_Bytes(SHA256_State * s, const void *p, int len);
void SHA256_Final(SHA256_State * s, unsigned char *output);
void SHA256_Simple(const void *p, int len, unsigned char *output);

typedef struct {
    uint64 h[8];
    unsigned char block[128];
    int blkused;
    uint32 len[4];
} SHA512_State;
void SHA512_Init(SHA512_State * s);
void SHA512_Bytes(SHA512_State * s, const void *p, int len);
void SHA512_Final(SHA512_State * s, unsigned char *output);
void SHA512_Simple(const void *p, int len, unsigned char *output);

struct ssh_cipher {
    void *(*make_context)(void);
    void (*free_context)(void *);
    void (*sesskey) (void *, unsigned char *key);	/* for SSH-1 */
    void (*encrypt) (void *, unsigned char *blk, int len);
    void (*decrypt) (void *, unsigned char *blk, int len);
    int blksize;
    char *text_name;
};

struct ssh2_cipher {
    void *(*make_context)(void);
    void (*free_context)(void *);
    void (*setiv) (void *, unsigned char *key);	/* for SSH-2 */
    void (*setkey) (void *, unsigned char *key);/* for SSH-2 */
    void (*encrypt) (void *, unsigned char *blk, int len);
    void (*decrypt) (void *, unsigned char *blk, int len);
    char *name;
    int blksize;
    int keylen;
    unsigned int flags;
#define SSH_CIPHER_IS_CBC	1
    char *text_name;
};

struct ssh2_ciphers {
    int nciphers;
    const struct ssh2_cipher *const *list;
};

struct ssh_mac {
    void *(*make_context)(void);
    void (*free_context)(void *);
    void (*setkey) (void *, unsigned char *key);
    void (*generate) (void *, unsigned char *blk, int len, unsigned long seq);
    int (*verify) (void *, unsigned char *blk, int len, unsigned long seq);
    char *name;
    int len;
    char *text_name;
};

struct ssh_hash {
    void *(*init)(void); /* also allocates context */
    void (*bytes)(void *, void *, int);
    void (*final)(void *, unsigned char *); /* also frees context */
    int hlen; /* output length in bytes */
    char *text_name;
};   

struct ssh_kex {
    char *name, *groupname;
    enum { KEXTYPE_DH, KEXTYPE_RSA } main_type;
    /* For DH */
    const unsigned char *pdata, *gdata; /* NULL means group exchange */
    int plen, glen;
    const struct ssh_hash *hash;
};

struct ssh_kexes {
    int nkexes;
    const struct ssh_kex *const *list;
};

struct ssh_signkey {
    void *(*newkey) (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);
    int (*openssh_fmtkey) (void *key, unsigned char *blob, int len);
    int (*pubkey_bits) (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 *siglen);
    char *name;
    char *keytype;		       /* for host key cache */
};

struct ssh_compress {
    char *name;
    void *(*compress_init) (void);
    void (*compress_cleanup) (void *);
    int (*compress) (void *, unsigned char *block, int len,
		     unsigned char **outblock, int *outlen);
    void *(*decompress_init) (void);
    void (*decompress_cleanup) (void *);
    int (*decompress) (void *, unsigned char *block, int len,
		       unsigned char **outblock, int *outlen);
    int (*disable_compression) (void *);
    char *text_name;
};

struct ssh2_userkey {
    const struct ssh_signkey *alg;     /* the key algorithm */
    void *data;			       /* the key data */
    char *comment;		       /* the key comment */
};

/* The maximum length of any hash algorithm used in kex. (bytes) */
#define SSH2_KEX_MAX_HASH_LEN (32) /* SHA-256 */

extern const struct ssh_cipher ssh_3des;
extern const struct ssh_cipher ssh_des;
extern const struct ssh_cipher ssh_blowfish_ssh1;
extern const struct ssh2_ciphers ssh2_3des;
extern const struct ssh2_ciphers ssh2_des;
extern const struct ssh2_ciphers ssh2_aes;
extern const struct ssh2_ciphers ssh2_blowfish;
extern const struct ssh2_ciphers ssh2_arcfour;
extern const struct ssh_hash ssh_sha1;
extern const struct ssh_hash ssh_sha256;
extern const struct ssh_kexes ssh_diffiehellman_group1;
extern const struct ssh_kexes ssh_diffiehellman_group14;
extern const struct ssh_kexes ssh_diffiehellman_gex;
extern const struct ssh_kexes ssh_rsa_kex;
extern const struct ssh_signkey ssh_dss;
extern const struct ssh_signkey ssh_rsa;
extern const struct ssh_mac ssh_hmac_md5;
extern const struct ssh_mac ssh_hmac_sha1;
extern const struct ssh_mac ssh_hmac_sha1_buggy;
extern const struct ssh_mac ssh_hmac_sha1_96;
extern const struct ssh_mac ssh_hmac_sha1_96_buggy;


/*
 * PuTTY version number formatted as an SSH version string. 
 */
extern char sshver[];

/*
 * Gross hack: pscp will try to start SFTP but fall back to scp1 if
 * that fails. This variable is the means by which scp.c can reach
 * into the SSH code and find out which one it got.
 */
extern int ssh_fallback_cmd(void *handle);

#ifndef MSCRYPTOAPI
void SHATransform(word32 * digest, word32 * data);
#endif

int random_byte(void);
void random_add_noise(void *noise, int length);
void random_add_heavynoise(void *noise, int length);

void logevent(void *, const char *);

/* Allocate and register a new channel for port forwarding */
void *new_sock_channel(void *handle, Socket s);
void ssh_send_port_open(void *channel, char *hostname, int port, char *org);

/* Exports from portfwd.c */
extern const char *pfd_newconnect(Socket * s, char *hostname, int port,
				  void *c, const Config *cfg,
				  int addressfamily);
/* desthost == NULL indicates dynamic (SOCKS) port forwarding */
extern const char *pfd_addforward(char *desthost, int destport, char *srcaddr,
				  int port, void *backhandle,
				  const Config *cfg, void **sockdata,
				  int address_family);
extern void pfd_close(Socket s);
extern void pfd_terminate(void *sockdata);
extern int pfd_send(Socket s, char *data, int len);
extern void pfd_confirm(Socket s);
extern void pfd_unthrottle(Socket s);
extern void pfd_override_throttle(Socket s, int enable);

/* Exports from x11fwd.c */
extern const char *x11_init(Socket *, char *, void *, void *, const char *,
			    int, const Config *);
extern void x11_close(Socket);
extern int x11_send(Socket, char *, int);
extern void *x11_invent_auth(char *, int, char *, int, int);
extern void x11_free_auth(void *);
extern void x11_unthrottle(Socket s);
extern void x11_override_throttle(Socket s, int enable);
extern int x11_get_screen_number(char *display);
void x11_get_real_auth(void *authv, char *display);
char *x11_display(const char *display);

/* Platform-dependent X11 functions */
extern void platform_get_x11_auth(char *display, int *proto,
                                  unsigned char *data, int *datalen);
extern const char platform_x11_best_transport[];
/* best X11 hostname for this platform if none specified */
SockAddr platform_get_x11_unix_address(int displaynum, char **canonicalname);
/* make up a SockAddr naming the address for displaynum */
char *platform_get_x_display(void);
/* allocated local X display string, if any */

Bignum copybn(Bignum b);
Bignum bn_power_2(int n);
void bn_restore_invariant(Bignum b);
Bignum bignum_from_long(unsigned long n);
void freebn(Bignum b);
Bignum modpow(Bignum base, Bignum exp, Bignum mod);
Bignum modmul(Bignum a, Bignum b, Bignum mod);
void decbn(Bignum n);
extern Bignum Zero, One;
Bignum bignum_from_bytes(const unsigned char *data, int nbytes);
int ssh1_read_bignum(const unsigned char *data, int len, Bignum * result);
int bignum_bitcount(Bignum bn);
int ssh1_bignum_length(Bignum bn);
int ssh2_bignum_length(Bignum bn);
int bignum_byte(Bignum bn, int i);
int bignum_bit(Bignum bn, int i);
void bignum_set_bit(Bignum bn, int i, int value);
int ssh1_write_bignum(void *data, Bignum bn);
Bignum biggcd(Bignum a, Bignum b);
unsigned short bignum_mod_short(Bignum number, unsigned short modulus);
Bignum bignum_add_long(Bignum number, unsigned long addend);
Bignum bigmul(Bignum a, Bignum b);
Bignum bigmuladd(Bignum a, Bignum b, Bignum addend);
Bignum bigdiv(Bignum a, Bignum b);
Bignum bigmod(Bignum a, Bignum b);
Bignum modinv(Bignum number, Bignum modulus);
Bignum bignum_bitmask(Bignum number);
Bignum bignum_rshift(Bignum number, int shift);
int bignum_cmp(Bignum a, Bignum b);
char *bignum_decimal(Bignum x);

#ifdef DEBUG
void diagbn(char *prefix, Bignum md);
#endif

void *dh_setup_group(const struct ssh_kex *kex);
void *dh_setup_gex(Bignum pval, Bignum gval);
void dh_cleanup(void *);
Bignum dh_create_e(void *, int nbits);
Bignum dh_find_K(void *, Bignum f);

int loadrsakey(const Filename *filename, struct RSAKey *key,
	       char *passphrase, const char **errorstr);
int rsakey_encrypted(const Filename *filename, char **comment);
int rsakey_pubblob(const Filename *filename, void **blob, int *bloblen,
		   char **commentptr, const char **errorstr);

int saversakey(const Filename *filename, struct RSAKey *key, char *passphrase);

extern int base64_decode_atom(char *atom, unsigned char *out);
extern int base64_lines(int datalen);
extern void base64_encode_atom(unsigned char *data, int n, char *out);
extern void base64_encode(FILE *fp, unsigned char *data, int datalen, int cpl);

/* ssh2_load_userkey can return this as an error */
extern struct ssh2_userkey ssh2_wrong_passphrase;
#define SSH2_WRONG_PASSPHRASE (&ssh2_wrong_passphrase)

int ssh2_userkey_encrypted(const Filename *filename, char **comment);
struct ssh2_userkey *ssh2_load_userkey(const Filename *filename,
				       char *passphrase, const char **errorstr);
unsigned char *ssh2_userkey_loadpub(const Filename *filename, char **algorithm,
				    int *pub_blob_len, char **commentptr,
				    const char **errorstr);
int ssh2_save_userkey(const Filename *filename, struct ssh2_userkey *key,
		      char *passphrase);
const struct ssh_signkey *find_pubkey_alg(const char *name);

enum {
    SSH_KEYTYPE_UNOPENABLE,
    SSH_KEYTYPE_UNKNOWN,
    SSH_KEYTYPE_SSH1, SSH_KEYTYPE_SSH2,
    SSH_KEYTYPE_OPENSSH, SSH_KEYTYPE_SSHCOM
};
int key_type(const Filename *filename);
char *key_type_to_str(int type);

int import_possible(int type);
int import_target_type(int type);
int import_encrypted(const Filename *filename, int type, char **comment);
int import_ssh1(const Filename *filename, int type,
		struct RSAKey *key, char *passphrase, const char **errmsg_p);
struct ssh2_userkey *import_ssh2(const Filename *filename, int type,
				 char *passphrase, const char **errmsg_p);
int export_ssh1(const Filename *filename, int type,
		struct RSAKey *key, char *passphrase);
int export_ssh2(const Filename *filename, int type,
                struct ssh2_userkey *key, char *passphrase);

void des3_decrypt_pubkey(unsigned char *key, unsigned char *blk, int len);
void des3_encrypt_pubkey(unsigned char *key, unsigned char *blk, int len);
void des3_decrypt_pubkey_ossh(unsigned char *key, unsigned char *iv,
			      unsigned char *blk, int len);
void des3_encrypt_pubkey_ossh(unsigned char *key, unsigned char *iv,
			      unsigned char *blk, int len);
void aes256_encrypt_pubkey(unsigned char *key, unsigned char *blk,
			   int len);
void aes256_decrypt_pubkey(unsigned char *key, unsigned char *blk,
			   int len);

void des_encrypt_xdmauth(unsigned char *key, unsigned char *blk, int len);
void des_decrypt_xdmauth(unsigned char *key, unsigned char *blk, int len);

/*
 * For progress updates in the key generation utility.
 */
#define PROGFN_INITIALISE 1
#define PROGFN_LIN_PHASE 2
#define PROGFN_EXP_PHASE 3
#define PROGFN_PHASE_EXTENT 4
#define PROGFN_READY 5
#define PROGFN_PROGRESS 6
typedef void (*progfn_t) (void *param, int action, int phase, int progress);

int rsa_generate(struct RSAKey *key, int bits, progfn_t pfn,
		 void *pfnparam);
int dsa_generate(struct dss_key *key, int bits, progfn_t pfn,
		 void *pfnparam);
Bignum primegen(int bits, int modulus, int residue, Bignum factor,
		int phase, progfn_t pfn, void *pfnparam);


/*
 * zlib compression.
 */
void *zlib_compress_init(void);
void zlib_compress_cleanup(void *);
void *zlib_decompress_init(void);
void zlib_decompress_cleanup(void *);
int zlib_compress_block(void *, unsigned char *block, int len,
			unsigned char **outblock, int *outlen);
int zlib_decompress_block(void *, unsigned char *block, int len,
			  unsigned char **outblock, int *outlen);

/*
 * SSH-1 agent messages.
 */
#define SSH1_AGENTC_REQUEST_RSA_IDENTITIES    1
#define SSH1_AGENT_RSA_IDENTITIES_ANSWER      2
#define SSH1_AGENTC_RSA_CHALLENGE             3
#define SSH1_AGENT_RSA_RESPONSE               4
#define SSH1_AGENTC_ADD_RSA_IDENTITY          7
#define SSH1_AGENTC_REMOVE_RSA_IDENTITY       8
#define SSH1_AGENTC_REMOVE_ALL_RSA_IDENTITIES 9	/* openssh private? */

/*
 * Messages common to SSH-1 and OpenSSH's SSH-2.
 */
#define SSH_AGENT_FAILURE                    5
#define SSH_AGENT_SUCCESS                    6

/*
 * OpenSSH's SSH-2 agent messages.
 */
#define SSH2_AGENTC_REQUEST_IDENTITIES          11
#define SSH2_AGENT_IDENTITIES_ANSWER            12
#define SSH2_AGENTC_SIGN_REQUEST                13
#define SSH2_AGENT_SIGN_RESPONSE                14
#define SSH2_AGENTC_ADD_IDENTITY                17
#define SSH2_AGENTC_REMOVE_IDENTITY             18
#define SSH2_AGENTC_REMOVE_ALL_IDENTITIES       19

/*
 * Need this to warn about support for the original SSH-2 keyfile
 * format.
 */
void old_keyfile_warning(void);
Commit	Line	Data
df3c4460	1	#include <stdio.h>
37508af4	2	#include <string.h>
37508af4	3
dcbde236	4	#include "puttymem.h"
d74d141c	5	#include "network.h"
5c72ca61	6	#include "int64.h"
9a30e26b	7	#include "misc.h"
dcbde236	8
2871113a	9	struct ssh_channel;
2871113a	10
5471d09a	11	extern void sshfwd_close(struct ssh_channel *c);
	12	extern int sshfwd_write(struct ssh_channel c, char , int);
	13	extern void sshfwd_unthrottle(struct ssh_channel *c, int bufsize);
	14
e5574168	15	/*
	16	* Useful thing.
	17	*/
	18	#ifndef lenof
	19	#define lenof(x) ( (sizeof((x))) / (sizeof(*(x))))
	20	#endif
	21
bea1ef5f	22	#define SSH_CIPHER_IDEA 1
9697bfd2	23	#define SSH_CIPHER_DES 2
bea1ef5f	24	#define SSH_CIPHER_3DES 3
	25	#define SSH_CIPHER_BLOWFISH 6
	26
e5574168	27	#ifdef MSCRYPTOAPI
	28	#define APIEXTRA 8
	29	#else
	30	#define APIEXTRA 0
	31	#endif
	32
3709bfe9	33	#ifndef BIGNUM_INTERNAL
	34	typedef void *Bignum;
	35	#endif
7cca0d81	36
374330e2	37	struct RSAKey {
	38	int bits;
	39	int bytes;
8f203108	40	#ifdef MSCRYPTOAPI
	41	unsigned long exponent;
	42	unsigned char *modulus;
	43	#else
7cca0d81	44	Bignum modulus;
	45	Bignum exponent;
	46	Bignum private_exponent;
9400cf6f	47	Bignum p;
	48	Bignum q;
	49	Bignum iqmp;
65a22376	50	#endif
65a22376	51	char *comment;
9400cf6f	52	};
9400cf6f	53
5c72ca61	54	struct dss_key {
	55	Bignum p, q, g, y, x;
	56	};
	57
0016d70b	58	int makekey(unsigned char data, int len, struct RSAKey result,
7cca0d81	59	unsigned char **keystr, int order);
0016d70b	60	int makeprivate(unsigned char data, int len, struct RSAKey result);
0016d70b	61	int rsaencrypt(unsigned char data, int length, struct RSAKey key);
7cca0d81	62	Bignum rsadecrypt(Bignum input, struct RSAKey *key);
	63	void rsasign(unsigned char data, int length, struct RSAKey key);
	64	void rsasanitise(struct RSAKey *key);
374330e2	65	int rsastr_len(struct RSAKey *key);
374330e2	66	void rsastr_fmt(char str, struct RSAKey key);
1c2a93c4	67	void rsa_fingerprint(char str, int len, struct RSAKey key);
014970c8	68	int rsa_verify(struct RSAKey *key);
3f2d010c	69	unsigned char rsa_public_blob(struct RSAKey key, int *len);
0016d70b	70	int rsa_public_blob_len(void *data, int maxlen);
5c58ad2d	71	void freersakey(struct RSAKey *key);
374330e2	72
	73	typedef unsigned int word32;
	74	typedef unsigned int uint32;
	75
71bedafe	76	unsigned long crc32_compute(const void *s, size_t len);
9a3a93a5	77	unsigned long crc32_update(unsigned long crc_input, const void *s, size_t len);
	78
	79	/* SSH CRC compensation attack detector */
0183b242	80	void *crcda_make_context(void);
	81	void crcda_free_context(void *handle);
	82	int detect_attack(void handle, unsigned char buf, uint32 len,
	83	unsigned char *IV);
374330e2	84
fae1a71b	85	/*
	86	* SSH2 RSA key exchange functions
	87	*/
	88	struct ssh_hash;
	89	void ssh_rsakex_newkey(char data, int len);
	90	void ssh_rsakex_freekey(void *key);
	91	int ssh_rsakex_klen(void *key);
	92	void ssh_rsakex_encrypt(const struct ssh_hash h, unsigned char in, int inlen,
	93	unsigned char *out, int outlen,
	94	void *key);
	95
48672163	96	typedef struct {
	97	uint32 h[4];
	98	} MD5_Core_State;
	99
374330e2	100	struct MD5Context {
8f203108	101	#ifdef MSCRYPTOAPI
	102	unsigned long hHash;
	103	#else
48672163	104	MD5_Core_State core;
bb093ca7	105	unsigned char block[64];
48672163	106	int blkused;
48672163	107	uint32 lenhi, lenlo;
8f203108	108	#endif
374330e2	109	};
	110
	111	void MD5Init(struct MD5Context *context);
	112	void MD5Update(struct MD5Context context, unsigned char const buf,
32874aea	113	unsigned len);
374330e2	114	void MD5Final(unsigned char digest[16], struct MD5Context *context);
f33ba69e	115	void MD5Simple(void const *p, unsigned len, unsigned char output[16]);
	116
	117	void *hmacmd5_make_context(void);
	118	void hmacmd5_free_context(void *handle);
447f7a7b	119	void hmacmd5_key(void handle, void const key, int len);
f33ba69e	120	void hmacmd5_do_hmac(void handle, unsigned char const blk, int len,
f33ba69e	121	unsigned char *hmac);
374330e2	122
e5574168	123	typedef struct {
	124	uint32 h[5];
	125	unsigned char block[64];
	126	int blkused;
	127	uint32 lenhi, lenlo;
	128	} SHA_State;
32874aea	129	void SHA_Init(SHA_State * s);
	130	void SHA_Bytes(SHA_State * s, void *p, int len);
	131	void SHA_Final(SHA_State * s, unsigned char *output);
7cca0d81	132	void SHA_Simple(void p, int len, unsigned char output);
e5574168	133
5c72ca61	134	void hmac_sha1_simple(void key, int keylen, void data, int datalen,
5c72ca61	135	unsigned char *output);
062e5811	136	typedef struct {
	137	uint32 h[8];
	138	unsigned char block[64];
	139	int blkused;
	140	uint32 lenhi, lenlo;
	141	} SHA256_State;
	142	void SHA256_Init(SHA256_State * s);
	143	void SHA256_Bytes(SHA256_State * s, const void *p, int len);
	144	void SHA256_Final(SHA256_State * s, unsigned char *output);
	145	void SHA256_Simple(const void p, int len, unsigned char output);
5c72ca61	146
	147	typedef struct {
	148	uint64 h[8];
	149	unsigned char block[128];
	150	int blkused;
	151	uint32 len[4];
	152	} SHA512_State;
	153	void SHA512_Init(SHA512_State * s);
	154	void SHA512_Bytes(SHA512_State * s, const void *p, int len);
	155	void SHA512_Final(SHA512_State * s, unsigned char *output);
	156	void SHA512_Simple(const void p, int len, unsigned char output);
	157
374330e2	158	struct ssh_cipher {
371e569c	159	void (make_context)(void);
371e569c	160	void (free_context)(void );
2e85c969	161	void (sesskey) (void , unsigned char key); / for SSH-1 */
371e569c	162	void (encrypt) (void , unsigned char *blk, int len);
371e569c	163	void (decrypt) (void , unsigned char *blk, int len);
0a3f1d48	164	int blksize;
371e569c	165	char *text_name;
0a3f1d48	166	};
	167
	168	struct ssh2_cipher {
371e569c	169	void (make_context)(void);
371e569c	170	void (free_context)(void );
2e85c969	171	void (setiv) (void , unsigned char key); / for SSH-2 */
2e85c969	172	void (setkey) (void , unsigned char key);/ for SSH-2 */
371e569c	173	void (encrypt) (void , unsigned char *blk, int len);
371e569c	174	void (decrypt) (void , unsigned char *blk, int len);
e5574168	175	char *name;
e5574168	176	int blksize;
d2a0e0be	177	int keylen;
97ab28d7	178	unsigned int flags;
97ab28d7	179	#define SSH_CIPHER_IS_CBC 1
371e569c	180	char *text_name;
e5574168	181	};
e5574168	182
0a3f1d48	183	struct ssh2_ciphers {
0a3f1d48	184	int nciphers;
65a22376	185	const struct ssh2_cipher const list;
0a3f1d48	186	};
0a3f1d48	187
e5574168	188	struct ssh_mac {
e0e1a00d	189	void (make_context)(void);
	190	void (free_context)(void );
	191	void (setkey) (void , unsigned char *key);
	192	void (generate) (void , unsigned char *blk, int len, unsigned long seq);
	193	int (verify) (void , unsigned char *blk, int len, unsigned long seq);
e5574168	194	char *name;
e5574168	195	int len;
6c135243	196	char *text_name;
e5574168	197	};
e5574168	198
b672f405	199	struct ssh_hash {
	200	void (init)(void); /* also allocates context */
	201	void (bytes)(void , void *, int);
	202	void (final)(void , unsigned char ); / also frees context */
	203	int hlen; /* output length in bytes */
c6daaa1a	204	char *text_name;
b672f405	205	};
b672f405	206
e5574168	207	struct ssh_kex {
d1aaf71d	208	char name, groupname;
fae1a71b	209	enum { KEXTYPE_DH, KEXTYPE_RSA } main_type;
	210	/* For DH */
	211	const unsigned char pdata, gdata; /* NULL means group exchange */
d1aaf71d	212	int plen, glen;
b672f405	213	const struct ssh_hash *hash;
e5574168	214	};
e5574168	215
34557659	216	struct ssh_kexes {
	217	int nkexes;
	218	const struct ssh_kex const list;
	219	};
	220
e055a386	221	struct ssh_signkey {
32874aea	222	void (newkey) (char *data, int len);
	223	void (freekey) (void key);
	224	char (fmtkey) (void *key);
	225	unsigned char (public_blob) (void key, int len);
	226	unsigned char (private_blob) (void key, int len);
	227	void (createkey) (unsigned char *pub_blob, int pub_len,
	228	unsigned char *priv_blob, int priv_len);
	229	void (openssh_createkey) (unsigned char *blob, int len);
	230	int (openssh_fmtkey) (void key, unsigned char *blob, int len);
47a6b94c	231	int (pubkey_bits) (void blob, int len);
32874aea	232	char (fingerprint) (void *key);
	233	int (verifysig) (void key, char *sig, int siglen,
	234	char *data, int datalen);
	235	unsigned char (sign) (void key, char data, int datalen,
	236	int *siglen);
e5574168	237	char *name;
32874aea	238	char keytype; / for host key cache */
e5574168	239	};
	240
	241	struct ssh_compress {
	242	char *name;
5366aed8	243	void (compress_init) (void);
	244	void (compress_cleanup) (void );
	245	int (compress) (void , unsigned char *block, int len,
32874aea	246	unsigned char *outblock, int outlen);
5366aed8	247	void (decompress_init) (void);
	248	void (decompress_cleanup) (void );
	249	int (decompress) (void , unsigned char *block, int len,
32874aea	250	unsigned char *outblock, int outlen);
5366aed8	251	int (disable_compression) (void );
5366aed8	252	char *text_name;
374330e2	253	};
374330e2	254
65a22376	255	struct ssh2_userkey {
	256	const struct ssh_signkey alg; / the key algorithm */
	257	void data; / the key data */
	258	char comment; / the key comment */
	259	};
	260
754c0df9	261	/* The maximum length of any hash algorithm used in kex. (bytes) */
	262	#define SSH2_KEX_MAX_HASH_LEN (32) /* SHA-256 */
	263
65a22376	264	extern const struct ssh_cipher ssh_3des;
	265	extern const struct ssh_cipher ssh_des;
	266	extern const struct ssh_cipher ssh_blowfish_ssh1;
	267	extern const struct ssh2_ciphers ssh2_3des;
0d7c43a6	268	extern const struct ssh2_ciphers ssh2_des;
65a22376	269	extern const struct ssh2_ciphers ssh2_aes;
65a22376	270	extern const struct ssh2_ciphers ssh2_blowfish;
a2add208	271	extern const struct ssh2_ciphers ssh2_arcfour;
b672f405	272	extern const struct ssh_hash ssh_sha1;
062e5811	273	extern const struct ssh_hash ssh_sha256;
34557659	274	extern const struct ssh_kexes ssh_diffiehellman_group1;
	275	extern const struct ssh_kexes ssh_diffiehellman_group14;
	276	extern const struct ssh_kexes ssh_diffiehellman_gex;
fae1a71b	277	extern const struct ssh_kexes ssh_rsa_kex;
65a22376	278	extern const struct ssh_signkey ssh_dss;
65a22376	279	extern const struct ssh_signkey ssh_rsa;
1993f323	280	extern const struct ssh_mac ssh_hmac_md5;
	281	extern const struct ssh_mac ssh_hmac_sha1;
	282	extern const struct ssh_mac ssh_hmac_sha1_buggy;
6668a75e	283	extern const struct ssh_mac ssh_hmac_sha1_96;
6668a75e	284	extern const struct ssh_mac ssh_hmac_sha1_96_buggy;
1993f323	285
65a22376	286
900a4ee6	287	/*
	288	* PuTTY version number formatted as an SSH version string.
	289	*/
	290	extern char sshver[];
	291
fd5e5847	292	/*
	293	* Gross hack: pscp will try to start SFTP but fall back to scp1 if
	294	* that fails. This variable is the means by which scp.c can reach
	295	* into the SSH code and find out which one it got.
	296	*/
51470298	297	extern int ssh_fallback_cmd(void *handle);
fd5e5847	298
8f203108	299	#ifndef MSCRYPTOAPI
32874aea	300	void SHATransform(word32 * digest, word32 * data);
8f203108	301	#endif
374330e2	302
	303	int random_byte(void);
	304	void random_add_noise(void *noise, int length);
6e522441	305	void random_add_heavynoise(void *noise, int length);
c5e9c988	306
cbe2d68f	307	void logevent(void , const char );
51470298	308
	309	/* Allocate and register a new channel for port forwarding */
	310	void new_sock_channel(void handle, Socket s);
6b78788a	311	void ssh_send_port_open(void channel, char hostname, int port, char *org);
e5574168	312
322d09a8	313	/* Exports from portfwd.c */
cbe2d68f	314	extern const char pfd_newconnect(Socket s, char *hostname, int port,
05581745	315	void c, const Config cfg,
05581745	316	int addressfamily);
820ebe3b	317	/* desthost == NULL indicates dynamic (SOCKS) port forwarding */
cbe2d68f	318	extern const char pfd_addforward(char desthost, int destport, char *srcaddr,
cbe2d68f	319	int port, void *backhandle,
05581745	320	const Config cfg, void *sockdata,
05581745	321	int address_family);
322d09a8	322	extern void pfd_close(Socket s);
fda2feb1	323	extern void pfd_terminate(void *sockdata);
322d09a8	324	extern int pfd_send(Socket s, char *data, int len);
	325	extern void pfd_confirm(Socket s);
	326	extern void pfd_unthrottle(Socket s);
	327	extern void pfd_override_throttle(Socket s, int enable);
	328
	329	/* Exports from x11fwd.c */
cbe2d68f	330	extern const char x11_init(Socket , char , void , void , const char ,
cbe2d68f	331	int, const Config *);
322d09a8	332	extern void x11_close(Socket);
322d09a8	333	extern int x11_send(Socket, char *, int);
b3ebaa28	334	extern void x11_invent_auth(char , int, char *, int, int);
fabd1805	335	extern void x11_free_auth(void *);
322d09a8	336	extern void x11_unthrottle(Socket s);
	337	extern void x11_override_throttle(Socket s, int enable);
	338	extern int x11_get_screen_number(char *display);
e0e7dff8	339	void x11_get_real_auth(void authv, char display);
fc0f17db	340	char x11_display(const char display);
322d09a8	341
fc0f17db	342	/* Platform-dependent X11 functions */
9bee6826	343	extern void platform_get_x11_auth(char display, int proto,
9bee6826	344	unsigned char data, int datalen);
fc0f17db	345	extern const char platform_x11_best_transport[];
	346	/* best X11 hostname for this platform if none specified */
	347	SockAddr platform_get_x11_unix_address(int displaynum, char **canonicalname);
	348	/* make up a SockAddr naming the address for displaynum */
46ed7b64	349	char *platform_get_x_display(void);
46ed7b64	350	/* allocated local X display string, if any */
9bee6826	351
7cca0d81	352	Bignum copybn(Bignum b);
3709bfe9	353	Bignum bn_power_2(int n);
3709bfe9	354	void bn_restore_invariant(Bignum b);
5c72ca61	355	Bignum bignum_from_long(unsigned long n);
e5574168	356	void freebn(Bignum b);
59600f67	357	Bignum modpow(Bignum base, Bignum exp, Bignum mod);
59600f67	358	Bignum modmul(Bignum a, Bignum b, Bignum mod);
7cca0d81	359	void decbn(Bignum n);
7cca0d81	360	extern Bignum Zero, One;
27cd7fc2	361	Bignum bignum_from_bytes(const unsigned char *data, int nbytes);
0016d70b	362	int ssh1_read_bignum(const unsigned char data, int len, Bignum result);
ddecd643	363	int bignum_bitcount(Bignum bn);
5c58ad2d	364	int ssh1_bignum_length(Bignum bn);
260f3dec	365	int ssh2_bignum_length(Bignum bn);
5c58ad2d	366	int bignum_byte(Bignum bn, int i);
9400cf6f	367	int bignum_bit(Bignum bn, int i);
9400cf6f	368	void bignum_set_bit(Bignum bn, int i, int value);
5c58ad2d	369	int ssh1_write_bignum(void *data, Bignum bn);
9400cf6f	370	Bignum biggcd(Bignum a, Bignum b);
	371	unsigned short bignum_mod_short(Bignum number, unsigned short modulus);
	372	Bignum bignum_add_long(Bignum number, unsigned long addend);
	373	Bignum bigmul(Bignum a, Bignum b);
5c72ca61	374	Bignum bigmuladd(Bignum a, Bignum b, Bignum addend);
	375	Bignum bigdiv(Bignum a, Bignum b);
	376	Bignum bigmod(Bignum a, Bignum b);
9400cf6f	377	Bignum modinv(Bignum number, Bignum modulus);
3709bfe9	378	Bignum bignum_bitmask(Bignum number);
9400cf6f	379	Bignum bignum_rshift(Bignum number, int shift);
8c3cd914	380	int bignum_cmp(Bignum a, Bignum b);
6e522441	381	char *bignum_decimal(Bignum x);
e5574168	382
a3412f52	383	#ifdef DEBUG
	384	void diagbn(char *prefix, Bignum md);
	385	#endif
	386
d1aaf71d	387	void dh_setup_group(const struct ssh_kex kex);
d1aaf71d	388	void *dh_setup_gex(Bignum pval, Bignum gval);
27cd7fc2	389	void dh_cleanup(void *);
	390	Bignum dh_create_e(void *, int nbits);
	391	Bignum dh_find_K(void *, Bignum f);
7cca0d81	392
9a30e26b	393	int loadrsakey(const Filename filename, struct RSAKey key,
222d54dc	394	char passphrase, const char *errorstr);
9a30e26b	395	int rsakey_encrypted(const Filename filename, char *comment);
222d54dc	396	int rsakey_pubblob(const Filename filename, void blob, int bloblen,
4bcf919e	397	char commentptr, const char errorstr);
7cca0d81	398
9a30e26b	399	int saversakey(const Filename filename, struct RSAKey key, char *passphrase);
65a22376	400
df3c4460	401	extern int base64_decode_atom(char atom, unsigned char out);
	402	extern int base64_lines(int datalen);
	403	extern void base64_encode_atom(unsigned char data, int n, char out);
	404	extern void base64_encode(FILE fp, unsigned char data, int datalen, int cpl);
65a22376	405
	406	/* ssh2_load_userkey can return this as an error */
	407	extern struct ssh2_userkey ssh2_wrong_passphrase;
	408	#define SSH2_WRONG_PASSPHRASE (&ssh2_wrong_passphrase)
	409
9a30e26b	410	int ssh2_userkey_encrypted(const Filename filename, char *comment);
9a30e26b	411	struct ssh2_userkey ssh2_load_userkey(const Filename filename,
222d54dc	412	char passphrase, const char *errorstr);
8a9977e5	413	unsigned char ssh2_userkey_loadpub(const Filename filename, char **algorithm,
	414	int pub_blob_len, char *commentptr,
	415	const char **errorstr);
9a30e26b	416	int ssh2_save_userkey(const Filename filename, struct ssh2_userkey key,
32874aea	417	char *passphrase);
47a6b94c	418	const struct ssh_signkey find_pubkey_alg(const char name);
65a22376	419
231ee168	420	enum {
	421	SSH_KEYTYPE_UNOPENABLE,
	422	SSH_KEYTYPE_UNKNOWN,
	423	SSH_KEYTYPE_SSH1, SSH_KEYTYPE_SSH2,
	424	SSH_KEYTYPE_OPENSSH, SSH_KEYTYPE_SSHCOM
	425	};
9a30e26b	426	int key_type(const Filename *filename);
231ee168	427	char *key_type_to_str(int type);
6e522441	428
9dda6459	429	int import_possible(int type);
9dda6459	430	int import_target_type(int type);
9a30e26b	431	int import_encrypted(const Filename filename, int type, char *comment);
9a30e26b	432	int import_ssh1(const Filename *filename, int type,
1e87cce5	433	struct RSAKey key, char passphrase, const char **errmsg_p);
9a30e26b	434	struct ssh2_userkey import_ssh2(const Filename filename, int type,
1e87cce5	435	char passphrase, const char *errmsg_p);
9a30e26b	436	int export_ssh1(const Filename *filename, int type,
	437	struct RSAKey key, char passphrase);
	438	int export_ssh2(const Filename *filename, int type,
4801c01c	439	struct ssh2_userkey key, char passphrase);
9dda6459	440
65a22376	441	void des3_decrypt_pubkey(unsigned char key, unsigned char blk, int len);
65a22376	442	void des3_encrypt_pubkey(unsigned char key, unsigned char blk, int len);
9dda6459	443	void des3_decrypt_pubkey_ossh(unsigned char key, unsigned char iv,
	444	unsigned char *blk, int len);
	445	void des3_encrypt_pubkey_ossh(unsigned char key, unsigned char iv,
	446	unsigned char *blk, int len);
32874aea	447	void aes256_encrypt_pubkey(unsigned char key, unsigned char blk,
	448	int len);
	449	void aes256_decrypt_pubkey(unsigned char key, unsigned char blk,
	450	int len);
9400cf6f	451
2f92b717	452	void des_encrypt_xdmauth(unsigned char key, unsigned char blk, int len);
b3ebaa28	453	void des_decrypt_xdmauth(unsigned char key, unsigned char blk, int len);
2f92b717	454
9400cf6f	455	/*
	456	* For progress updates in the key generation utility.
	457	*/
7c7f6893	458	#define PROGFN_INITIALISE 1
	459	#define PROGFN_LIN_PHASE 2
	460	#define PROGFN_EXP_PHASE 3
	461	#define PROGFN_PHASE_EXTENT 4
	462	#define PROGFN_READY 5
	463	#define PROGFN_PROGRESS 6
5c72ca61	464	typedef void (progfn_t) (void param, int action, int phase, int progress);
9400cf6f	465
32874aea	466	int rsa_generate(struct RSAKey *key, int bits, progfn_t pfn,
32874aea	467	void *pfnparam);
5c72ca61	468	int dsa_generate(struct dss_key *key, int bits, progfn_t pfn,
	469	void *pfnparam);
	470	Bignum primegen(int bits, int modulus, int residue, Bignum factor,
	471	int phase, progfn_t pfn, void *pfnparam);
4ba9b64b	472
d74d141c	473
4ba9b64b	474	/*
	475	* zlib compression.
	476	*/
5366aed8	477	void *zlib_compress_init(void);
	478	void zlib_compress_cleanup(void *);
	479	void *zlib_decompress_init(void);
	480	void zlib_decompress_cleanup(void *);
	481	int zlib_compress_block(void , unsigned char block, int len,
4ba9b64b	482	unsigned char *outblock, int outlen);
5366aed8	483	int zlib_decompress_block(void , unsigned char block, int len,
4ba9b64b	484	unsigned char *outblock, int outlen);
1983e559	485
1983e559	486	/*
2e85c969	487	* SSH-1 agent messages.
1983e559	488	*/
	489	#define SSH1_AGENTC_REQUEST_RSA_IDENTITIES 1
	490	#define SSH1_AGENT_RSA_IDENTITIES_ANSWER 2
	491	#define SSH1_AGENTC_RSA_CHALLENGE 3
	492	#define SSH1_AGENT_RSA_RESPONSE 4
	493	#define SSH1_AGENTC_ADD_RSA_IDENTITY 7
	494	#define SSH1_AGENTC_REMOVE_RSA_IDENTITY 8
32874aea	495	#define SSH1_AGENTC_REMOVE_ALL_RSA_IDENTITIES 9 /* openssh private? */
1983e559	496
1983e559	497	/*
2e85c969	498	* Messages common to SSH-1 and OpenSSH's SSH-2.
1983e559	499	*/
	500	#define SSH_AGENT_FAILURE 5
	501	#define SSH_AGENT_SUCCESS 6
	502
	503	/*
2e85c969	504	* OpenSSH's SSH-2 agent messages.
1983e559	505	*/
	506	#define SSH2_AGENTC_REQUEST_IDENTITIES 11
	507	#define SSH2_AGENT_IDENTITIES_ANSWER 12
	508	#define SSH2_AGENTC_SIGN_REQUEST 13
	509	#define SSH2_AGENT_SIGN_RESPONSE 14
	510	#define SSH2_AGENTC_ADD_IDENTITY 17
	511	#define SSH2_AGENTC_REMOVE_IDENTITY 18
	512	#define SSH2_AGENTC_REMOVE_ALL_IDENTITIES 19
7bedb13c	513
7bedb13c	514	/*
2e85c969	515	* Need this to warn about support for the original SSH-2 keyfile
7bedb13c	516	* format.
	517	*/
	518	void old_keyfile_warning(void);