add-key works
[gnupg.git] / g10 / passphrase.c
1 /* passphrase.c -  Get a passphrase
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG 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  * GNUPG 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  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <assert.h>
27 #include "util.h"
28 #include "memory.h"
29 #include "options.h"
30 #include "ttyio.h"
31 #include "cipher.h"
32 #include "keydb.h"
33 #include "main.h"
34
35 static int pwfd = -1;
36 static char *next_pw = NULL;
37 static char *last_pw = NULL;
38
39 static void hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create );
40
41 void
42 set_passphrase_fd( int fd )
43 {
44     pwfd = fd;
45 }
46
47 int
48 get_passphrase_fd()
49 {
50     return pwfd;
51 }
52
53 /****************
54  * Set the passphrase to be used for the next query and only for the next
55  * one.
56  */
57 void
58 set_next_passphrase( const char *s )
59 {
60     m_free(next_pw);
61     next_pw = NULL;
62     if( s ) {
63         next_pw = m_alloc_secure( strlen(s)+1 );
64         strcpy(next_pw, s );
65     }
66 }
67
68 /****************
69  * Get the last passphrase used in passphrase_to_dek.
70  * Note: This removes the passphrase from this modules and
71  * the caller must free the result.  May return NULL:
72  */
73 char *
74 get_last_passphrase()
75 {
76     char *p = last_pw;
77     last_pw = NULL;
78     return p;
79 }
80
81
82 /****************
83  * Get a passphrase for the secret key with KEYID, display TEXT
84  * if the user needs to enter the passphrase.
85  * mode 0 = standard, 2 = create new passphrase
86  * Returns: a DEK with a session key; caller must free
87  *          or NULL if the passphrase was not correctly repeated.
88  *          (only for mode 2)
89  *          a dek->keylen of 0 means: no passphrase entered.
90  *          (only for mode 2)
91  */
92 DEK *
93 passphrase_to_dek( u32 *keyid, int cipher_algo, STRING2KEY *s2k, int mode )
94 {
95     char *pw = NULL;
96     DEK *dek;
97     STRING2KEY help_s2k;
98
99     if( !s2k ) {
100         s2k = &help_s2k;
101         s2k->mode = 0;
102         /* this should be MD5 if cipher is IDEA, but because we do
103          * not have IDEA, we use the default one, the user
104          * can select it from the commandline
105          */
106         s2k->hash_algo = opt.def_digest_algo?opt.def_digest_algo
107                                             :DEFAULT_DIGEST_ALGO;
108     }
109
110     if( keyid && !opt.batch && !next_pw ) {
111         char *ustr;
112         tty_printf("Need a pass phrase to unlock the secret key for:\n");
113         tty_printf("  \"" );
114         ustr = get_user_id_string( keyid );
115         tty_print_string( ustr, strlen(ustr) );
116         m_free(ustr);
117         tty_printf("\"\n\n");
118
119     }
120     if( next_pw ) {
121         pw = next_pw;
122         next_pw = NULL;
123     }
124     else if( pwfd != -1 ) { /* read the passphrase from the file */
125         int i, len;
126
127         if( !opt.batch )
128             tty_printf("Reading from file descriptor %d ...", pwfd );
129         for( pw = NULL, i = len = 100; ; i++ ) {
130             if( i >= len-1 ) {
131                 char *pw2 = pw;
132                 len += 100;
133                 pw = m_alloc_secure( len );
134                 if( pw2 )
135                     memcpy(pw, pw2, i );
136                 i=0;
137             }
138             if( read( pwfd, pw+i, 1) != 1 || pw[i] == '\n' )
139                 break;
140         }
141         pw[i] = 0;
142         if( !opt.batch )
143             tty_printf("\b\b\b   \n" );
144     }
145     else if( opt.batch )
146         log_fatal("Can't query password in batchmode\n");
147     else {
148         pw = tty_get_hidden("Enter pass phrase: " );
149         tty_kill_prompt();
150         if( mode == 2 ) {
151             char *pw2 = tty_get_hidden("Repeat pass phrase: " );
152             tty_kill_prompt();
153             if( strcmp(pw, pw2) ) {
154                 m_free(pw2);
155                 m_free(pw);
156                 return NULL;
157             }
158             m_free(pw2);
159         }
160     }
161     dek = m_alloc_secure( sizeof *dek );
162     dek->algo = cipher_algo;
163     if( !*pw && mode == 2 )
164         dek->keylen = 0;
165     else
166         hash_passphrase( dek, pw, s2k, mode==2 );
167     m_free(last_pw);
168     last_pw = pw;
169     return dek;
170 }
171
172
173 /****************
174  * Hash a passphrase using the supplied s2k. If create is true, create
175  * a new salt or whatelse must be filled into the s2k for a new key.
176  * always needs: dek->algo, s2k->mode, s2k->hash_algo.
177  */
178 static void
179 hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
180 {
181     MD_HANDLE md;
182
183     assert( s2k->hash_algo );
184     dek->keylen = 0;
185     md = md_open( s2k->hash_algo, 1);
186     if( s2k->mode == 1 || s2k->mode == 4 ) {
187         if( create )
188             randomize_buffer(s2k->salt, 8, 1);
189         md_write( md, s2k->salt, 8 );
190     }
191     md_write( md, pw, strlen(pw) );
192     md_final( md );
193     dek->keylen = cipher_get_keylen( dek->algo ) / 8;
194     assert(dek->keylen > 0 && dek->keylen <= DIM(dek->key) );
195     memcpy( dek->key, md_read(md,0), dek->keylen );
196     md_close(md);
197 }
198