← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to fs/ecryptfs/crypto.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/ecryptfs/crypto.c
266
266
                                 &mount_crypt_stat->global_auth_tok_list,
267
267
                                 mount_crypt_stat_list) {
268
268
                list_del(&auth_tok->mount_crypt_stat_list);
269
 
                mount_crypt_stat->num_global_auth_toks--;
270
269
                if (auth_tok->global_auth_tok_key
271
270
                    && !(auth_tok->flags & ECRYPTFS_AUTH_TOK_INVALID))
272
271
                        key_put(auth_tok->global_auth_tok_key);
1025
1024
}
1026
1025
 
1027
1026
/**
1028
 
 * contains_ecryptfs_marker - check for the ecryptfs marker
 
1027
 * ecryptfs_validate_marker - check for the ecryptfs marker
1029
1028
 * @data: The data block in which to check
1030
1029
 *
1031
 
 * Returns one if marker found; zero if not found
 
1030
 * Returns zero if marker found; -EINVAL if not found
1032
1031
 */
1033
 
static int contains_ecryptfs_marker(char *data)
 
1032
static int ecryptfs_validate_marker(char *data)
1034
1033
{
1035
1034
        u32 m_1, m_2;
1036
1035
 
1037
1036
        m_1 = get_unaligned_be32(data);
1038
1037
        m_2 = get_unaligned_be32(data + 4);
1039
1038
        if ((m_1 ^ MAGIC_ECRYPTFS_MARKER) == m_2)
1040
 
                return 1;
 
1039
                return 0;
1041
1040
        ecryptfs_printk(KERN_DEBUG, "m_1 = [0x%.8x]; m_2 = [0x%.8x]; "
1042
1041
                        "MAGIC_ECRYPTFS_MARKER = [0x%.8x]\n", m_1, m_2,
1043
1042
                        MAGIC_ECRYPTFS_MARKER);
1044
1043
        ecryptfs_printk(KERN_DEBUG, "(m_1 ^ MAGIC_ECRYPTFS_MARKER) = "
1045
1044
                        "[0x%.8x]\n", (m_1 ^ MAGIC_ECRYPTFS_MARKER));
1046
 
        return 0;
 
1045
        return -EINVAL;
1047
1046
}
1048
1047
 
1049
1048
struct ecryptfs_flag_map_elem {
1202
1201
        return rc;
1203
1202
}
1204
1203
 
1205
 
int ecryptfs_read_and_validate_header_region(char *data,
1206
 
                                             struct inode *ecryptfs_inode)
 
1204
int ecryptfs_read_and_validate_header_region(struct inode *inode)
1207
1205
{
1208
 
        struct ecryptfs_crypt_stat *crypt_stat =
1209
 
                &(ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat);
 
1206
        u8 file_size[ECRYPTFS_SIZE_AND_MARKER_BYTES];
 
1207
        u8 *marker = file_size + ECRYPTFS_FILE_SIZE_BYTES;
1210
1208
        int rc;
1211
1209
 
1212
 
        if (crypt_stat->extent_size == 0)
1213
 
                crypt_stat->extent_size = ECRYPTFS_DEFAULT_EXTENT_SIZE;
1214
 
        rc = ecryptfs_read_lower(data, 0, crypt_stat->extent_size,
1215
 
                                 ecryptfs_inode);
1216
 
        if (rc < 0) {
1217
 
                printk(KERN_ERR "%s: Error reading header region; rc = [%d]\n",
1218
 
                       __func__, rc);
1219
 
                goto out;
1220
 
        }
1221
 
        if (!contains_ecryptfs_marker(data + ECRYPTFS_FILE_SIZE_BYTES)) {
1222
 
                rc = -EINVAL;
1223
 
        } else
1224
 
                rc = 0;
1225
 
out:
 
1210
        rc = ecryptfs_read_lower(file_size, 0, ECRYPTFS_SIZE_AND_MARKER_BYTES,
 
1211
                                 inode);
 
1212
        if (rc < ECRYPTFS_SIZE_AND_MARKER_BYTES)
 
1213
                return rc >= 0 ? -EINVAL : rc;
 
1214
        rc = ecryptfs_validate_marker(marker);
 
1215
        if (!rc)
 
1216
                ecryptfs_i_size_init(file_size, inode);
1226
1217
        return rc;
1227
1218
}
1228
1219
 
1243
1234
        (*written) = 6;
1244
1235
}
1245
1236
 
1246
 
struct kmem_cache *ecryptfs_header_cache_1;
1247
 
struct kmem_cache *ecryptfs_header_cache_2;
 
1237
struct kmem_cache *ecryptfs_header_cache;
1248
1238
 
1249
1239
/**
1250
1240
 * ecryptfs_write_headers_virt
1389
1379
                rc = -ENOMEM;
1390
1380
                goto out;
1391
1381
        }
 
1382
        /* Zeroed page ensures the in-header unencrypted i_size is set to 0 */
1392
1383
        rc = ecryptfs_write_headers_virt(virt, virt_len, &size, crypt_stat,
1393
1384
                                         ecryptfs_dentry);
1394
1385
        if (unlikely(rc)) {
1452
1443
        crypt_stat->metadata_size = ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE;
1453
1444
}
1454
1445
 
 
1446
void ecryptfs_i_size_init(const char *page_virt, struct inode *inode)
 
1447
{
 
1448
        struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
 
1449
        struct ecryptfs_crypt_stat *crypt_stat;
 
1450
        u64 file_size;
 
1451
 
 
1452
        crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
 
1453
        mount_crypt_stat =
 
1454
                &ecryptfs_superblock_to_private(inode->i_sb)->mount_crypt_stat;
 
1455
        if (mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED) {
 
1456
                file_size = i_size_read(ecryptfs_inode_to_lower(inode));
 
1457
                if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
 
1458
                        file_size += crypt_stat->metadata_size;
 
1459
        } else
 
1460
                file_size = get_unaligned_be64(page_virt);
 
1461
        i_size_write(inode, (loff_t)file_size);
 
1462
        crypt_stat->flags |= ECRYPTFS_I_SIZE_INITIALIZED;
 
1463
}
 
1464
 
1455
1465
/**
1456
1466
 * ecryptfs_read_headers_virt
1457
1467
 * @page_virt: The virtual address into which to read the headers
1477
1487
        crypt_stat->mount_crypt_stat = &ecryptfs_superblock_to_private(
1478
1488
                ecryptfs_dentry->d_sb)->mount_crypt_stat;
1479
1489
        offset = ECRYPTFS_FILE_SIZE_BYTES;
1480
 
        rc = contains_ecryptfs_marker(page_virt + offset);
1481
 
        if (rc == 0) {
1482
 
                rc = -EINVAL;
 
1490
        rc = ecryptfs_validate_marker(page_virt + offset);
 
1491
        if (rc)
1483
1492
                goto out;
1484
 
        }
 
1493
        if (!(crypt_stat->flags & ECRYPTFS_I_SIZE_INITIALIZED))
 
1494
                ecryptfs_i_size_init(page_virt, ecryptfs_dentry->d_inode);
1485
1495
        offset += MAGIC_ECRYPTFS_MARKER_SIZE_BYTES;
1486
1496
        rc = ecryptfs_process_flags(crypt_stat, (page_virt + offset),
1487
1497
                                    &bytes_read);
1546
1556
        return rc;
1547
1557
}
1548
1558
 
1549
 
int ecryptfs_read_and_validate_xattr_region(char *page_virt,
1550
 
                                            struct dentry *ecryptfs_dentry)
 
1559
int ecryptfs_read_and_validate_xattr_region(struct dentry *dentry,
 
1560
                                            struct inode *inode)
1551
1561
{
 
1562
        u8 file_size[ECRYPTFS_SIZE_AND_MARKER_BYTES];
 
1563
        u8 *marker = file_size + ECRYPTFS_FILE_SIZE_BYTES;
1552
1564
        int rc;
1553
1565
 
1554
 
        rc = ecryptfs_read_xattr_region(page_virt, ecryptfs_dentry->d_inode);
1555
 
        if (rc)
1556
 
                goto out;
1557
 
        if (!contains_ecryptfs_marker(page_virt + ECRYPTFS_FILE_SIZE_BYTES)) {
1558
 
                printk(KERN_WARNING "Valid data found in [%s] xattr, but "
1559
 
                        "the marker is invalid\n", ECRYPTFS_XATTR_NAME);
1560
 
                rc = -EINVAL;
1561
 
        }
1562
 
out:
 
1566
        rc = ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry),
 
1567
                                     ECRYPTFS_XATTR_NAME, file_size,
 
1568
                                     ECRYPTFS_SIZE_AND_MARKER_BYTES);
 
1569
        if (rc < ECRYPTFS_SIZE_AND_MARKER_BYTES)
 
1570
                return rc >= 0 ? -EINVAL : rc;
 
1571
        rc = ecryptfs_validate_marker(marker);
 
1572
        if (!rc)
 
1573
                ecryptfs_i_size_init(file_size, inode);
1563
1574
        return rc;
1564
1575
}
1565
1576
 
1589
1600
        ecryptfs_copy_mount_wide_flags_to_inode_flags(crypt_stat,
1590
1601
                                                      mount_crypt_stat);
1591
1602
        /* Read the first page from the underlying file */
1592
 
        page_virt = kmem_cache_alloc(ecryptfs_header_cache_1, GFP_USER);
 
1603
        page_virt = kmem_cache_alloc(ecryptfs_header_cache, GFP_USER);
1593
1604
        if (!page_virt) {
1594
1605
                rc = -ENOMEM;
1595
1606
                printk(KERN_ERR "%s: Unable to allocate page_virt\n",
1634
1645
out:
1635
1646
        if (page_virt) {
1636
1647
                memset(page_virt, 0, PAGE_CACHE_SIZE);
1637
 
                kmem_cache_free(ecryptfs_header_cache_1, page_virt);
 
1648
                kmem_cache_free(ecryptfs_header_cache, page_virt);
1638
1649
        }
1639
1650
        return rc;
1640
1651
}