~siretart/cryptsetup/debian

« back to all changes in this revision

Viewing changes to luks/keymanage.c

  • Committer: Reinhard Tartler
  • Date: 2008-05-25 17:39:22 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: siretart@tauware.de-20080525173922-popbnh1gtbt3rxis
merge new upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
43
43
        (__a - 1) / __b + 1;        \
44
44
})
45
45
 
 
46
static inline int round_up_modulo(int x, int m) {
 
47
        return div_round_up(x, m) * m;
 
48
}
46
49
 
47
50
struct luks_masterkey *LUKS_alloc_masterkey(int keylength)
48
51
76
79
        
77
80
        devfd = open(device,O_RDONLY | O_DIRECT | O_SYNC);
78
81
        if(-1 == devfd) {
79
 
                fprintf(stderr, _("Can't open device: %s\n"), device);
 
82
                set_error(_("Can't open device: %s\n"), device);
80
83
                return -EINVAL; 
81
84
        }
82
85
 
83
86
        if(read_blockwise(devfd, hdr, sizeof(struct luks_phdr)) < sizeof(struct luks_phdr)) {
84
87
                r = -EIO;
85
88
        } else if(memcmp(hdr->magic, luksMagic, LUKS_MAGIC_L)) { /* Check magic */
86
 
                fprintf(stderr, _("%s is not a LUKS partition\n"), device);
 
89
                set_error(_("%s is not a LUKS partition\n"), device);
87
90
                r = -EINVAL;
88
91
        } else if(memcmp(hdr->hashSpec, "sha1", 4)) { /* Check for SHA1 - other hashspecs are not implemented ATM */
89
 
                fputs(_("unknown hash spec in phdr"), stderr);
 
92
                set_error(_("unknown hash spec in phdr\n"), stderr);
90
93
                r = -EINVAL;
91
94
        } else if((hdr->version = ntohs(hdr->version)) != 1) {  /* Convert every uint16/32_t item from network byte order */
92
 
                fprintf(stderr, _("unknown version %d\n"), hdr->version);
 
95
                set_error(_("unknown LUKS version %d\n"), hdr->version);
93
96
                r = -EINVAL;
94
97
        } else {
95
98
                hdr->payloadOffset      = ntohl(hdr->payloadOffset);
115
118
        struct luks_phdr convHdr;
116
119
        int r;
117
120
        
118
 
        devfd = open(device,O_RDWR | O_DIRECT | O_SYNC);
 
121
        devfd = open(device,O_RDWR | O_DIRECT | O_SYNC | O_EXCL);
119
122
        if(-1 == devfd) { 
120
 
                fprintf(stderr, _("Can't open device: %s\n"), device);
 
123
                set_error(_("Can't open device %s"), device);
121
124
                return -EINVAL;
122
125
        }
123
126
 
141
144
        return r;
142
145
}       
143
146
 
144
 
inline int round_up_modulo(int x, int m) {
145
 
        return div_round_up(x, m) * m;
146
 
}
147
 
 
148
147
int LUKS_generate_phdr(struct luks_phdr *header, 
149
148
                       const struct luks_masterkey *mk, const char *cipherName,
150
149
                       const char *cipherMode, unsigned int stripes,
193
192
        currentSector = round_up_modulo(currentSector, alignPayload);
194
193
 
195
194
        header->payloadOffset=currentSector;
 
195
 
196
196
        uuid_generate(partitionUuid);
197
 
        uuid_unparse(partitionUuid, header->uuid);
 
197
        uuid_unparse(partitionUuid, header->uuid);
198
198
 
199
199
        return 0;
200
200
}
210
210
        int r;
211
211
        
212
212
        if(hdr->keyblock[keyIndex].active != LUKS_KEY_DISABLED) {
213
 
                fprintf(stderr, _("key %d active, purge first.\n"), keyIndex);
 
213
                set_error( _("key %d active, purge first"), keyIndex);
214
214
                return -EINVAL;
215
215
        }
216
216
                
217
217
        if(hdr->keyblock[keyIndex].stripes < LUKS_STRIPES) {
218
 
                fprintf(stderr,_("key material section %d includes too few stripes. Header manipulation?\n"),keyIndex);
 
218
                set_error(_("key material section %d includes too few stripes. Header manipulation?"),keyIndex);
219
219
                 return -EINVAL;
220
220
        }
221
221
        r = getRandom(hdr->keyblock[keyIndex].passwordSalt, LUKS_SALTSIZE);
247
247
                                    hdr->keyblock[keyIndex].keyMaterialOffset,
248
248
                                    backend);
249
249
        if(r < 0) {
250
 
                fprintf(stderr,"Failed to write to key storage.\n");
 
250
                if(!get_error())
 
251
                        set_error("Failed to write to key storage");
251
252
                goto out;
252
253
        }
253
254
 
262
263
        return r;
263
264
}
264
265
 
 
266
/* Try to open a particular key slot,
 
267
 
 
268
 */
 
269
 
265
270
int LUKS_open_key(const char *device, 
266
271
                  unsigned int keyIndex, 
267
272
                  const char *password, 
277
282
        int r;
278
283
        
279
284
        if(hdr->keyblock[keyIndex].active != LUKS_KEY_ENABLED) {
280
 
#ifdef LUKS_DEBUG
281
 
                fprintf(stderr, _("key %d is disabled.\n"), keyIndex);
282
 
#endif
283
285
                return -EINVAL;
284
286
        }
285
287
        
303
305
                                      hdr->keyblock[keyIndex].keyMaterialOffset,
304
306
                                      backend);
305
307
        if(r < 0) {
306
 
                fprintf(stderr,"Failed to read from key storage\n");
 
308
                if(!get_error())
 
309
                        set_error("Failed to read from key storage");
307
310
                goto out;
308
311
        }
309
312
 
337
340
 
338
341
        *mk=LUKS_alloc_masterkey(hdr->keyBytes);
339
342
        for(i=0; i<LUKS_NUMKEYS; i++) {
340
 
                r = LUKS_open_key(device, i, password, passwordLen, hdr, *mk, backend);
341
 
                
342
 
                if(r == 0) { 
343
 
                        printf("key slot %d unlocked.\n",i);
344
 
                        return i; 
345
 
                } 
346
 
                /* Do not retry for errors that are no -EPERM or -EINVAL, former meaning password wrong, latter key slot inactive */
347
 
                if ((r != -EPERM) && (r != -EINVAL)) 
348
 
                        return r;
 
343
            r = LUKS_open_key(device, i, password, passwordLen, hdr, *mk, backend);
 
344
            if(r == 0) { 
 
345
                return i; 
 
346
            } 
 
347
            /* Do not retry for errors that are no -EPERM or -EINVAL, former meaning password wrong, latter key slot inactive */
 
348
            if ((r != -EPERM) && (r != -EINVAL)) 
 
349
                return r;
349
350
        }
350
351
        /* Warning, early returns above */
351
352
        return -EPERM;
387
388
        
388
389
        devfd = open(device, O_RDWR | O_DIRECT);
389
390
        if(devfd == -1) {
390
 
                fprintf(stderr, _("Can't open device: %s\n"), device);
 
391
                set_error(_("Can't open device %s"), device);
391
392
                return -EINVAL;
392
393
        }
393
394
 
417
418
int LUKS_del_key(const char *device, unsigned int keyIndex)
418
419
{
419
420
        struct luks_phdr hdr;
420
 
        unsigned int i, startOffset, endOffset, stripesLen;
 
421
        unsigned int startOffset, endOffset, stripesLen;
421
422
        int r;
422
423
        
423
424
        r = LUKS_read_phdr(device, &hdr);
464
465
{
465
466
        return PBKDF2_performance_check()/2;
466
467
}
 
468
 
 
469
int LUKS_device_ready(const char *device, int mode)
 
470
{
 
471
        int devfd = open(device, mode | O_DIRECT | O_SYNC);
 
472
        if(devfd < 0) {
 
473
                set_error(_("Can't open device for %s%saccess: %s\n"), (mode & O_EXCL)?_("exclusive "):"", (mode & O_RDWR)?_("writable "):"read-only ", device);
 
474
                return 0;
 
475
        }
 
476
        close(devfd);
 
477
        return 1;
 
478
}
 
479
 
 
480
// Local Variables:
 
481
// c-basic-offset: 8
 
482
// indent-tabs-mode: nil
 
483
// End: