trunk/Src/wptFileStatDlg.cpp

/* wptFileStatDlg.cpp - List the status of an OpenPGP file
 *      Copyright (C) 2002-2003, 2005-2006, 2009 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <time.h>
#include <sys/types.h>
#include <assert.h>

#include "resource.h"
#include "wptTypes.h"
#include "wptGPG.h"
#include "wptCommonCtl.h"
#include "wptContext.h"
#include "wptErrors.h"
#include "wptW32API.h"
#include "wptUTF8.h"
#include "openpgp.h"


/* Make sure that the list won't consume too much memory. */
#define MAX_PKTS 1024

/* Return humand readable public key algo. */
static const char*
get_pubkey_algo (int algo)
{       
    if (algo == 17)
        return "DSA";   
   else if (is_ELGAMAL (algo))
        return "ELG";   
    else if (is_RSA (algo))
        return "RSA";
    return NULL;
}


/* Return human readable symmetric algo. */
const char*
get_symkey_algo (int algo)
{
    switch (algo) {
    case 0: return "PLAINTEXT";
    case 1: return "IDEA";
    case 2: return "3DES"; 
    case 3: return "CAST5";
    case 4: return "BLOWFISH";
    case 7: return "AES128";
    case 8: return "AES192";
    case 9: return "AES256";
    default: break;
    }    
    return "UNKNOWN";
}


/* Return human readable hash algo. */
static const char*
get_digest_algo (int algo)
{
    switch (algo) {
    case 0: return "NONE";
    case 1: return "MD5";
    case 2: return "SHA1";
    case 3: return "RMD160";
    case 5: return "MD2";
    case 8: return "SHA256";
    case 9: return "SHA384";
    case 10:return "SHA512";
    case 11:return "SHA224";
    default: break;
    }
    return "UNKNOWN";
}


/* Return human readable compress algo. */
static const char*
get_compress_algo (int algo)
{
    switch (algo) {
    case 0: return "NONE";
    case 1: return "ZIB";
    case 2: return "ZLIB";
    case 3: return "BZIP2";
    default: break;
    }
    return "UNKNOWN";
}


/* Return human string to key algo. */
static const char*
get_s2k_algo (int algo)
{
    switch (algo) {
    case 0: return "SIMPLE";
    case 1: return "SALTED";
    case 3: return "ITER+SALTED";
    default:break;
    }
    return "INVALID";
}


/* List all OpenPGP packets from the file @file.
   Return value: number of packets. */
static int
do_list_packets (HWND list, const char *file)
{
    PACKET *pkt;
    gpg_iobuf_t inp = NULL;
    armor_filter_context_t afx;
    char inf[1024], *p;
    char fmtdate[128];
    size_t n;
    int rc;    

    if (!list || !file) {
        log_debug ("do_list_packets: invalid parameters\n");
        return -1;
    }

    inp = gpg_iobuf_open (file);
    if (!inp) {
        log_box (_("File Manager"), MB_ERR, "%s: %s", file,
                 winpt_strerror (WPTERR_FILE_OPEN));
        return -1;
    }
    gpg_iobuf_ioctl (inp, 3, 1, NULL); /* disable cache */
    if (gpg_use_armor_filter (inp)) {
        memset (&afx, 0, sizeof (afx));
        gpg_iobuf_push_filter (inp, gpg_armor_filter, &afx);
    }
    pkt = (PACKET *)calloc(1, sizeof *pkt);
    gpg_init_packet (pkt);
    n=0;
    while ((rc = gpg_parse_packet (inp, pkt)) != -1) {
        switch (pkt->pkttype) {
        case PKT_PUBKEY_ENC:
            {PKT_pubkey_enc *enc = pkt->pkt.pubkey_enc; n++;
            if (!enc)
                break;
            _snprintf (inf, DIM(inf)-1,
                       "public key encryted packet: "
                       "version %d, algo %s, keyid 0x%08X",
                       enc->version, get_pubkey_algo(enc->pubkey_algo), 
                       enc->keyid[1]);
            listbox_add_string (list, inf);}
            break;
                
        case PKT_SYMKEY_ENC:
            {PKT_symkey_enc *enc = pkt->pkt.symkey_enc; n++;
                if (!enc)
                break;
            _snprintf (inf, DIM(inf)-1,
                       "symmetric key encrypted packet: "
                       "version %d, cipher %s, s2k %s, hash %s",
                       enc->version, get_symkey_algo (enc->cipher_algo),
                       get_s2k_algo (enc->s2k.mode), 
                       get_digest_algo (enc->s2k.hash_algo));
            listbox_add_string (list, inf); }
            break;

        case PKT_ENCRYPTED:     
        case PKT_ENCRYPTED_MDC:
            {PKT_encrypted *enc = pkt->pkt.encrypted; n++;
            if (!enc)
                break;
            _snprintf (inf, DIM (inf)-1,        
                       "encrypted data packet: mdc method %d, length %d",
                       enc->mdc_method, enc->len);
            listbox_add_string (list, inf); }
            break;

        case PKT_PUBLIC_KEY:
        case PKT_PUBLIC_SUBKEY:
            {PKT_public_key *pk = pkt->pkt.public_key; n++;
            if (!pk)
                break;
            _snprintf (inf, DIM(inf)-1,
                       "public key packet: version %d, algo %s, created %s",
                       pk->version, get_pubkey_algo (pk->pubkey_algo),
                       get_locale_date (pk->timestamp, fmtdate, 
                                        DIM (fmtdate)-1));
            listbox_add_string (list, inf); }
            break;

        case PKT_SECRET_KEY:
        case PKT_SECRET_SUBKEY:     
            {PKT_secret_key *sk = pkt->pkt.secret_key; n++;
            if (!sk)
                break;
            _snprintf (inf, DIM (inf)-1,
                       "secret key packet: "
                       "version %d, algo %s, created %s mode %d",
                       sk->version,  get_pubkey_algo (sk->pubkey_algo),
                       get_locale_date (sk->timestamp, fmtdate, 
                                        DIM(fmtdate)-1),
                       sk->protect.s2k.mode);
            listbox_add_string (list, inf); }
            break;
            
        case PKT_SIGNATURE:
            {PKT_signature *sig = pkt->pkt.signature; n++;
            if (!sig)
                break;
            _snprintf (inf, DIM(inf)-1,
                       "signature packet: "
                       "version %d, algo %s, keyid 0x%08X, created %s",
                       sig->version, get_pubkey_algo(sig->pubkey_algo), 
                       sig->keyid[1],
                       get_locale_date (sig->timestamp, fmtdate, 
                                        DIM(fmtdate)-1));
            listbox_add_string (list, inf); }
            break;

                
        case PKT_USER_ID:
            {PKT_user_id *id = pkt->pkt.user_id; n++;
            if (!id)
                break;
            p = utf8_to_native (id->name);
            _snprintf (inf, DIM (inf)-1, "user id packet: %s", p);
            free_if_alloc (p);
            listbox_add_string (list, inf); }
            break;
            
        case PKT_COMPRESSED:
            {PKT_compressed *zip = pkt->pkt.compressed; n++;
            if (!zip)
                break;
            _snprintf (inf, DIM (inf)-1, 
                       "compressed packet: algo %s, length %d",
                       get_compress_algo(zip->algorithm), zip->len);
            listbox_add_string (list, inf); }
            break;

        default:
            break;
        }
        gpg_free_packet (pkt);
        gpg_init_packet (pkt);
        if (n > MAX_PKTS) {
            listbox_add_string(list, "--last shown packet--");
            break;
        }
    }
    gpg_iobuf_close (inp);
    safe_free (pkt);
    return n;
}


/* Dialog box procedure for showing file status. */
BOOL CALLBACK
file_stat_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    switch (msg) {
    case WM_INITDIALOG:
        if (do_list_packets (GetDlgItem (dlg, IDC_FILE_STAT_LIST), 
                             (const char*)lparam) < 1) {
            msg_box (dlg, _("No valid OpenPGP data found."), 
                     _("File Status"), MB_ERR);
            EndDialog (dlg, FALSE);
            return TRUE;
        }
        SetWindowText (dlg, _("File Status"));
        SetForegroundWindow (dlg);
        break;
        
    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            EndDialog (dlg, TRUE);
            break;

        case IDCANCEL:
            EndDialog (dlg, FALSE);
            break;
        }
        break;
    }
    
    return FALSE;
}
1	twoaday	225	/* wptFileStatDlg.cpp - List the status of an OpenPGP file
2	twoaday	328	* Copyright (C) 2002-2003, 2005-2006, 2009 Timo Schulz
3	werner	36	*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* WinPT is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*/
16			#ifdef HAVE_CONFIG_H
17			#include <config.h>
18			#endif
19
20			#include <windows.h>
21			#include <time.h>
22			#include <sys/types.h>
23	twoaday	310	#include <assert.h>
24	werner	36
25	werner	47	#include "resource.h"
26	werner	36	#include "wptTypes.h"
27			#include "wptGPG.h"
28			#include "wptCommonCtl.h"
29			#include "wptContext.h"
30			#include "wptErrors.h"
31			#include "wptW32API.h"
32	twoaday	225	#include "wptUTF8.h"
33	werner	36	#include "openpgp.h"
34
35	twoaday	328
36	twoaday	271	/* Make sure that the list won't consume too much memory. */
37			#define MAX_PKTS 1024
38
39	twoaday	256	/* Return humand readable public key algo. */
40	werner	36	static const char*
41			get_pubkey_algo (int algo)
42			{
43			if (algo == 17)
44			return "DSA";
45			else if (is_ELGAMAL (algo))
46			return "ELG";
47			else if (is_RSA (algo))
48			return "RSA";
49			return NULL;
50			}
51
52
53	twoaday	256	/* Return human readable symmetric algo. */
54	werner	36	const char*
55			get_symkey_algo (int algo)
56			{
57			switch (algo) {
58			case 0: return "PLAINTEXT";
59			case 1: return "IDEA";
60			case 2: return "3DES";
61			case 3: return "CAST5";
62			case 4: return "BLOWFISH";
63	twoaday	226	case 7: return "AES128";
64			case 8: return "AES192";
65			case 9: return "AES256";
66	twoaday	178	default: break;
67	werner	36	}
68			return "UNKNOWN";
69			}
70
71
72	twoaday	256	/* Return human readable hash algo. */
73	werner	36	static const char*
74			get_digest_algo (int algo)
75			{
76			switch (algo) {
77			case 0: return "NONE";
78			case 1: return "MD5";
79			case 2: return "SHA1";
80			case 3: return "RMD160";
81			case 5: return "MD2";
82			case 8: return "SHA256";
83			case 9: return "SHA384";
84			case 10:return "SHA512";
85	twoaday	328	case 11:return "SHA224";
86	twoaday	178	default: break;
87	werner	36	}
88			return "UNKNOWN";
89			}
90
91
92	twoaday	256	/* Return human readable compress algo. */
93	werner	36	static const char*
94			get_compress_algo (int algo)
95			{
96			switch (algo) {
97			case 0: return "NONE";
98			case 1: return "ZIB";
99			case 2: return "ZLIB";
100			case 3: return "BZIP2";
101	twoaday	178	default: break;
102	werner	36	}
103			return "UNKNOWN";
104			}
105
106
107	twoaday	256	/* Return human string to key algo. */
108	werner	36	static const char*
109	twoaday	178	get_s2k_algo (int algo)
110			{
111			switch (algo) {
112			case 0: return "SIMPLE";
113			case 1: return "SALTED";
114			case 3: return "ITER+SALTED";
115			default:break;
116			}
117			return "INVALID";
118			}
119
120
121	twoaday	225	/* List all OpenPGP packets from the file @file.
122	werner	36	Return value: number of packets. */
123			static int
124			do_list_packets (HWND list, const char *file)
125			{
126			PACKET *pkt;
127			gpg_iobuf_t inp = NULL;
128			armor_filter_context_t afx;
129	twoaday	225	char inf[1024], *p;
130	twoaday	328	char fmtdate[128];
131			size_t n;
132			int rc;
133	werner	36
134			if (!list \|\| !file) {
135	twoaday	271	log_debug ("do_list_packets: invalid parameters\n");
136	werner	36	return -1;
137			}
138
139			inp = gpg_iobuf_open (file);
140			if (!inp) {
141	twoaday	256	log_box (_("File Manager"), MB_ERR, "%s: %s", file,
142	werner	36	winpt_strerror (WPTERR_FILE_OPEN));
143			return -1;
144			}
145	twoaday	256	gpg_iobuf_ioctl (inp, 3, 1, NULL); /* disable cache */
146	werner	36	if (gpg_use_armor_filter (inp)) {
147			memset (&afx, 0, sizeof (afx));
148			gpg_iobuf_push_filter (inp, gpg_armor_filter, &afx);
149			}
150			pkt = (PACKET )calloc(1, sizeof pkt);
151			gpg_init_packet (pkt);
152	twoaday	328	n=0;
153	werner	36	while ((rc = gpg_parse_packet (inp, pkt)) != -1) {
154			switch (pkt->pkttype) {
155			case PKT_PUBKEY_ENC:
156			{PKT_pubkey_enc *enc = pkt->pkt.pubkey_enc; n++;
157			if (!enc)
158			break;
159	twoaday	271	_snprintf (inf, DIM(inf)-1,
160	twoaday	328	"public key encryted packet: "
161			"version %d, algo %s, keyid 0x%08X",
162			enc->version, get_pubkey_algo(enc->pubkey_algo),
163			enc->keyid[1]);
164	werner	36	listbox_add_string (list, inf);}
165			break;
166
167			case PKT_SYMKEY_ENC:
168			{PKT_symkey_enc *enc = pkt->pkt.symkey_enc; n++;
169	twoaday	328	if (!enc)
170	werner	36	break;
171	twoaday	271	_snprintf (inf, DIM(inf)-1,
172	twoaday	328	"symmetric key encrypted packet: "
173			"version %d, cipher %s, s2k %s, hash %s",
174			enc->version, get_symkey_algo (enc->cipher_algo),
175			get_s2k_algo (enc->s2k.mode),
176			get_digest_algo (enc->s2k.hash_algo));
177	twoaday	178	listbox_add_string (list, inf); }
178	werner	36	break;
179
180			case PKT_ENCRYPTED:
181			case PKT_ENCRYPTED_MDC:
182			{PKT_encrypted *enc = pkt->pkt.encrypted; n++;
183			if (!enc)
184			break;
185	twoaday	328	_snprintf (inf, DIM (inf)-1,
186			"encrypted data packet: mdc method %d, length %d",
187			enc->mdc_method, enc->len);
188	twoaday	225	listbox_add_string (list, inf); }
189	werner	36	break;
190
191			case PKT_PUBLIC_KEY:
192			case PKT_PUBLIC_SUBKEY:
193			{PKT_public_key *pk = pkt->pkt.public_key; n++;
194			if (!pk)
195			break;
196	twoaday	328	_snprintf (inf, DIM(inf)-1,
197			"public key packet: version %d, algo %s, created %s",
198			pk->version, get_pubkey_algo (pk->pubkey_algo),
199			get_locale_date (pk->timestamp, fmtdate,
200			DIM (fmtdate)-1));
201	twoaday	225	listbox_add_string (list, inf); }
202	werner	36	break;
203
204			case PKT_SECRET_KEY:
205			case PKT_SECRET_SUBKEY:
206			{PKT_secret_key *sk = pkt->pkt.secret_key; n++;
207			if (!sk)
208			break;
209	twoaday	328	_snprintf (inf, DIM (inf)-1,
210			"secret key packet: "
211			"version %d, algo %s, created %s mode %d",
212			sk->version, get_pubkey_algo (sk->pubkey_algo),
213			get_locale_date (sk->timestamp, fmtdate,
214			DIM(fmtdate)-1),
215			sk->protect.s2k.mode);
216	twoaday	225	listbox_add_string (list, inf); }
217	werner	36	break;
218	twoaday	225
219	werner	36	case PKT_SIGNATURE:
220			{PKT_signature *sig = pkt->pkt.signature; n++;
221			if (!sig)
222			break;
223	twoaday	328	_snprintf (inf, DIM(inf)-1,
224			"signature packet: "
225			"version %d, algo %s, keyid 0x%08X, created %s",
226			sig->version, get_pubkey_algo(sig->pubkey_algo),
227			sig->keyid[1],
228			get_locale_date (sig->timestamp, fmtdate,
229			DIM(fmtdate)-1));
230	twoaday	225	listbox_add_string (list, inf); }
231	werner	36	break;
232
233
234			case PKT_USER_ID:
235			{PKT_user_id *id = pkt->pkt.user_id; n++;
236			if (!id)
237			break;
238	twoaday	225	p = utf8_to_native (id->name);
239	twoaday	271	_snprintf (inf, DIM (inf)-1, "user id packet: %s", p);
240	twoaday	225	free_if_alloc (p);
241			listbox_add_string (list, inf); }
242	werner	36	break;
243
244			case PKT_COMPRESSED:
245			{PKT_compressed *zip = pkt->pkt.compressed; n++;
246			if (!zip)
247			break;
248	twoaday	328	_snprintf (inf, DIM (inf)-1,
249			"compressed packet: algo %s, length %d",
250			get_compress_algo(zip->algorithm), zip->len);
251	twoaday	225	listbox_add_string (list, inf); }
252	werner	36	break;
253	twoaday	178
254	twoaday	65	default:
255			break;
256	werner	36	}
257			gpg_free_packet (pkt);
258			gpg_init_packet (pkt);
259	twoaday	328	if (n > MAX_PKTS) {
260			listbox_add_string(list, "--last shown packet--");
261	twoaday	271	break;
262	twoaday	328	}
263	werner	36	}
264			gpg_iobuf_close (inp);
265			safe_free (pkt);
266			return n;
267			}
268
269
270			/* Dialog box procedure for showing file status. */
271			BOOL CALLBACK
272			file_stat_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
273			{
274			switch (msg) {
275	twoaday	328	case WM_INITDIALOG:
276			if (do_list_packets (GetDlgItem (dlg, IDC_FILE_STAT_LIST),
277			(const char*)lparam) < 1) {
278	twoaday	271	msg_box (dlg, _("No valid OpenPGP data found."),
279			_("File Status"), MB_ERR);
280	werner	36	EndDialog (dlg, FALSE);
281	twoaday	225	return TRUE;
282	werner	36	}
283	twoaday	256	SetWindowText (dlg, _("File Status"));
284	werner	36	SetForegroundWindow (dlg);
285			break;
286
287			case WM_COMMAND:
288			switch (LOWORD (wparam)) {
289			case IDOK:
290			EndDialog (dlg, TRUE);
291			break;
292	twoaday	213
293			case IDCANCEL:
294			EndDialog (dlg, FALSE);
295			break;
296	werner	36	}
297			break;
298			}
299
300			return FALSE;
301			}