add salted and iterated mode
[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 #include "i18n.h"
35
36 static int pwfd = -1;
37 static char *next_pw = NULL;
38 static char *last_pw = NULL;
39
40 static void hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create );
41
42 void
43 set_passphrase_fd( int fd )
44 {
45     pwfd = fd;
46 }
47
48 int
49 get_passphrase_fd()
50 {
51     return pwfd;
52 }
53
54 /****************
55  * Set the passphrase to be used for the next query and only for the next
56  * one.
57  */
58 void
59 set_next_passphrase( const char *s )
60 {
61     m_free(next_pw);
62     next_pw = NULL;
63     if( s ) {
64         next_pw = m_alloc_secure( strlen(s)+1 );
65         strcpy(next_pw, s );
66     }
67 }
68
69 /****************
70  * Get the last passphrase used in passphrase_to_dek.
71  * Note: This removes the passphrase from this modules and
72  * the caller must free the result.  May return NULL:
73  */
74 char *
75 get_last_passphrase()
76 {
77     char *p = last_pw;
78     last_pw = NULL;
79     return p;
80 }
81
82
83 /****************
84  * Get a passphrase for the secret key with KEYID, display TEXT
85  * if the user needs to enter the passphrase.
86  * mode 0 = standard, 2 = create new passphrase
87  * Returns: a DEK with a session key; caller must free
88  *          or NULL if the passphrase was not correctly repeated.
89  *          (only for mode 2)
90  *          a dek->keylen of 0 means: no passphrase entered.
91  *          (only for mode 2)
92  */
93 DEK *
94 passphrase_to_dek( u32 *keyid, int cipher_algo, STRING2KEY *s2k, int mode )
95 {
96     char *pw = NULL;
97     DEK *dek;
98     STRING2KEY help_s2k;
99
100     if( !s2k ) {
101         s2k = &help_s2k;
102         s2k->mode = 0;
103         /* this should be MD5 if cipher is IDEA, but because we do
104          * not have IDEA, we use the default one, the user
105          * can select it from the commandline
106          */
107         s2k->hash_algo = opt.def_digest_algo?opt.def_digest_algo
108                                             :DEFAULT_DIGEST_ALGO;
109     }
110
111     if( keyid && !opt.batch && !next_pw ) {
112         PKT_public_key *pk = m_alloc_clear( sizeof *pk );
113         size_t n;
114         char *p;
115
116         tty_printf(_("\nYou need a passphrase to unlock the secret key for\n"
117                      "user: \"") );
118         p = get_user_id( keyid, &n );
119         tty_print_string( p, n );
120         m_free(p);
121         tty_printf("\"\n");
122
123         if( !get_pubkey( pk, keyid ) ) {
124             const char *s = pubkey_algo_to_string( pk->pubkey_algo );
125             tty_printf( _("(%u-bit %s key, ID %08lX, created %s)\n"),
126                        nbits_from_pk( pk ), s?s:"?", (ulong)keyid[1],
127                        strtimestamp(pk->timestamp) );
128         }
129         tty_printf("\n");
130         free_public_key( pk );
131     }
132     if( next_pw ) {
133         pw = next_pw;
134         next_pw = NULL;
135     }
136     else if( pwfd != -1 ) { /* read the passphrase from the file */
137         int i, len;
138
139         if( !opt.batch )
140             tty_printf("Reading from file descriptor %d ...", pwfd );
141         for( pw = NULL, i = len = 100; ; i++ ) {
142             if( i >= len-1 ) {
143                 char *pw2 = pw;
144                 len += 100;
145                 pw = m_alloc_secure( len );
146                 if( pw2 )
147                     memcpy(pw, pw2, i );
148                 i=0;
149             }
150             if( read( pwfd, pw+i, 1) != 1 || pw[i] == '\n' )
151                 break;
152         }
153         pw[i] = 0;
154         if( !opt.batch )
155             tty_printf("\b\b\b   \n" );
156     }
157     else if( opt.batch )
158         log_fatal("Can't query password in batchmode\n");
159     else {
160         pw = tty_get_hidden("Enter pass phrase: " );
161         tty_kill_prompt();
162         if( mode == 2 ) {
163             char *pw2 = tty_get_hidden("Repeat pass phrase: " );
164             tty_kill_prompt();
165             if( strcmp(pw, pw2) ) {
166                 m_free(pw2);
167                 m_free(pw);
168                 return NULL;
169             }
170             m_free(pw2);
171         }
172     }
173     dek = m_alloc_secure( sizeof *dek );
174     dek->algo = cipher_algo;
175     if( !*pw && mode == 2 )
176         dek->keylen = 0;
177     else
178         hash_passphrase( dek, pw, s2k, mode==2 );
179     m_free(last_pw);
180     last_pw = pw;
181     return dek;
182 }
183
184
185 /****************
186  * Hash a passphrase using the supplied s2k. If create is true, create
187  * a new salt or whatelse must be filled into the s2k for a new key.
188  * always needs: dek->algo, s2k->mode, s2k->hash_algo.
189  */
190 static void
191 hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
192 {
193     MD_HANDLE md;
194
195     assert( s2k->hash_algo );
196     dek->keylen = 0;
197     md = md_open( s2k->hash_algo, 1);
198     if( s2k->mode == 1 || s2k->mode == 3 ) {
199         ulong count = 0;
200         int len = strlen(pw);
201         int len2 = len + 8;
202
203         if( create )
204             randomize_buffer(s2k->salt, 8, 1);
205
206         if( s2k->mode == 3 ) {
207             count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
208             log_info("s2k iteration count=%lu\n", count );
209         }
210         for(;;) {
211             md_write( md, s2k->salt, 8 );
212             md_write( md, pw, len );
213             if( count < len2 )
214                 break;
215             count -= len2;
216         }
217         if( count ) {
218             if( count < 8 )
219                 md_write( md, s2k->salt, count );
220             else {
221                 md_write( md, s2k->salt, 8 );
222                 count -= 8;
223                 assert( count <= len );
224                 md_write( md, pw, count );
225             }
226         }
227     }
228     else
229         md_write( md, pw, strlen(pw) );
230     md_final( md );
231     dek->keylen = cipher_get_keylen( dek->algo ) / 8;
232     assert(dek->keylen > 0 && dek->keylen <= DIM(dek->key) );
233     memcpy( dek->key, md_read(md,0), dek->keylen );
234     md_close(md);
235 }
236