src/third_party/sqlite/src/test/corrupt.test

   1 # 2004 August 30 {}
   2 #
   3 # The author disclaims copyright to this source code.  In place of
   4 # a legal notice, here is a blessing:
   5 #
   6 #    May you do good and not evil.
   7 #    May you find forgiveness for yourself and forgive others.
   8 #    May you share freely, never taking more than you give.
   9 #
  10 #***********************************************************************
  11 # This file implements regression tests for SQLite library.
  12 #
  13 # This file implements tests to make sure SQLite does not crash or
  14 # segfault if it sees a corrupt database file.
  15 #
  16 # $Id: corrupt.test,v 1.12 2009/07/13 09:41:45 danielk1977 Exp $
  17
  18 catch {file delete -force test.db test.db-journal test.bu}
  19
  20 set testdir [file dirname $argv0]
  21 source $testdir/tester.tcl
  22
  23 # Do not use a codec for tests in this file, as the database file is
  24 # manipulated directly using tcl scripts (using the [hexio_write] command).
  25 #
  26 do_not_use_codec
  27
  28 # Construct a large database for testing.
  29 #
  30 do_test corrupt-1.1 {
  31   execsql {
  32     BEGIN;
  33     CREATE TABLE t1(x);
  34     INSERT INTO t1 VALUES(randstr(100,100));
  35     INSERT INTO t1 VALUES(randstr(90,90));
  36     INSERT INTO t1 VALUES(randstr(80,80));
  37     INSERT INTO t1 SELECT x || randstr(5,5) FROM t1;
  38     INSERT INTO t1 SELECT x || randstr(6,6) FROM t1;
  39     INSERT INTO t1 SELECT x || randstr(7,7) FROM t1;
  40     INSERT INTO t1 SELECT x || randstr(8,8) FROM t1;
  41     INSERT INTO t1 VALUES(randstr(3000,3000));
  42     INSERT INTO t1 SELECT x || randstr(9,9) FROM t1;
  43     INSERT INTO t1 SELECT x || randstr(10,10) FROM t1;
  44     INSERT INTO t1 SELECT x || randstr(11,11) FROM t1;
  45     INSERT INTO t1 SELECT x || randstr(12,12) FROM t1;
  46     CREATE INDEX t1i1 ON t1(x);
  47     CREATE TABLE t2 AS SELECT * FROM t1;
  48     DELETE FROM t2 WHERE rowid%5!=0;
  49     COMMIT;
  50   }
  51 } {}
  52 integrity_check corrupt-1.2
  53
  54 # Copy file $from into $to
  55 #
  56 proc copy_file {from to} {
  57   set f [open $from]
  58   fconfigure $f -translation binary
  59   set t [open $to w]
  60   fconfigure $t -translation binary
  61   puts -nonewline $t [read $f [file size $from]]
  62   close $t
  63   close $f
  64 }
  65
  66 # Setup for the tests.  Make a backup copy of the good database in test.bu.
  67 # Create a string of garbage data that is 256 bytes long.
  68 #
  69 copy_file test.db test.bu
  70 set fsize [file size test.db]
  71 set junk "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  72 while {[string length $junk]<256} {append junk $junk}
  73 set junk [string range $junk 0 255]
  74
  75 # Go through the database and write garbage data into each 256 segment
  76 # of the file.  Then do various operations on the file to make sure that
  77 # the database engine can recover gracefully from the corruption.
  78 #
  79 for {set i [expr {1*256}]} {$i<$fsize-256} {incr i 256} {
  80   set tn [expr {$i/256}]
  81   db close
  82   copy_file test.bu test.db
  83   set fd [open test.db r+]
  84   fconfigure $fd -translation binary
  85   seek $fd $i
  86   puts -nonewline $fd $junk
  87   close $fd
  88   do_test corrupt-2.$tn.1 {
  89     sqlite3 db test.db
  90     catchsql {SELECT count(*) FROM sqlite_master}
  91     set x {}
  92   } {}
  93   do_test corrupt-2.$tn.2 {
  94     catchsql {SELECT count(*) FROM t1}
  95     set x {}
  96   } {}
  97   do_test corrupt-2.$tn.3 {
  98     catchsql {SELECT count(*) FROM t1 WHERE x>'abcdef'}
  99     set x {}
 100   } {}
 101   do_test corrupt-2.$tn.4 {
 102     catchsql {SELECT count(*) FROM t2}
 103     set x {}
 104   } {}
 105   do_test corrupt-2.$tn.5 {
 106     catchsql {CREATE TABLE t3 AS SELECT * FROM t1}
 107     set x {}
 108   } {}
 109   do_test corrupt-2.$tn.6 {
 110     catchsql {DROP TABLE t1}
 111     set x {}
 112   } {}
 113   do_test corrupt-2.$tn.7 {
 114     catchsql {PRAGMA integrity_check}
 115     set x {}
 116   } {}
 117
 118   # Check that no page references were leaked.
 119   do_test corrupt-2.$tn.8 {
 120     set bt [btree_from_db db]
 121     db_enter db
 122     array set stats [btree_pager_stats $bt]
 123     db_leave db
 124     set stats(ref)
 125   } {0}
 126 }
 127
 128 #------------------------------------------------------------------------
 129 # For these tests, swap the rootpage entries of t1 (a table) and t1i1 (an
 130 # index on t1) in sqlite_master. Then perform a few different queries
 131 # and make sure this is detected as corruption.
 132 #
 133 do_test corrupt-3.1 {
 134   db close
 135   copy_file test.bu test.db
 136   sqlite3 db test.db
 137   list
 138 } {}
 139 do_test corrupt-3.2 {
 140   set t1_r [execsql {SELECT rootpage FROM sqlite_master WHERE name = 't1i1'}]
 141   set t1i1_r [execsql {SELECT rootpage FROM sqlite_master WHERE name = 't1'}]
 142   set cookie [expr [execsql {PRAGMA schema_version}] + 1]
 143   execsql "
 144     PRAGMA writable_schema = 1;
 145     UPDATE sqlite_master SET rootpage = $t1_r WHERE name = 't1';
 146     UPDATE sqlite_master SET rootpage = $t1i1_r WHERE name = 't1i1';
 147     PRAGMA writable_schema = 0;
 148     PRAGMA schema_version = $cookie;
 149   "
 150 } {}
 151
 152 # This one tests the case caught by code in checkin [2313].
 153 do_test corrupt-3.3 {
 154   db close
 155   sqlite3 db test.db
 156   catchsql {
 157     INSERT INTO t1 VALUES('abc');
 158   }
 159 } {1 {database disk image is malformed}}
 160 do_test corrupt-3.4 {
 161   db close
 162   sqlite3 db test.db
 163   catchsql {
 164     SELECT * FROM t1;
 165   }
 166 } {1 {database disk image is malformed}}
 167 do_test corrupt-3.5 {
 168   db close
 169   sqlite3 db test.db
 170   catchsql {
 171     SELECT * FROM t1 WHERE oid = 10;
 172   }
 173 } {1 {database disk image is malformed}}
 174 do_test corrupt-3.6 {
 175   db close
 176   sqlite3 db test.db
 177   catchsql {
 178     SELECT * FROM t1 WHERE x = 'abcde';
 179   }
 180 } {1 {database disk image is malformed}}
 181
 182 do_test corrupt-4.1 {
 183   db close
 184   file delete -force test.db test.db-journal
 185   sqlite3 db test.db
 186   execsql {
 187     PRAGMA page_size = 1024;
 188     CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT);
 189   }
 190   for {set i 0} {$i < 10} {incr i} {
 191     set text [string repeat $i 220]
 192     execsql { INSERT INTO t1 VALUES($i, $text) }
 193   }
 194   execsql { CREATE INDEX i1 ON t1(b) }
 195 } {}
 196 do_test corrupt-4.2 {
 197   set iRoot [db one {SELECT rootpage FROM sqlite_master WHERE name = 'i1'}]
 198   set iOffset [hexio_get_int [hexio_read test.db [expr 12+($iRoot-1)*1024] 2]]
 199   set data [hexio_render_int32 [expr $iRoot - 1]]
 200   hexio_write test.db [expr ($iRoot-1)*1024 + $iOffset] $data
 201   db close
 202   sqlite3 db test.db
 203
 204   # The following DELETE statement attempts to delete a cell stored on the
 205   # root page of index i1. After this cell is deleted it must be replaced
 206   # by a cell retrieved from the child page (a leaf) of the deleted cell.
 207   # This will fail, as the block modified the database image so that the
 208   # child page of the deleted cell is from a table (intkey) b-tree, not an
 209   # index b-tree as expected. At one point this was causing an assert()
 210   # to fail.
 211   catchsql { DELETE FROM t1 WHERE rowid = 3 }
 212 } {1 {database disk image is malformed}}
 213
 214 do_test corrupt-5.1 {
 215   db close
 216   file delete -force test.db test.db-journal
 217   sqlite3 db test.db
 218
 219   execsql { PRAGMA page_size = 1024 }
 220   set ct "CREATE TABLE t1(c0 "
 221   set i 0
 222   while {[string length $ct] < 950} { append ct ", c[incr i]" }
 223   append ct ")"
 224   execsql $ct
 225 } {}
 226
 227 do_test corrupt-5.2 {
 228   db close
 229   hexio_write test.db 108 00000000
 230   sqlite3 db test.db
 231   catchsql { SELECT * FROM sqlite_master }
 232 } {1 {database disk image is malformed}}
 233
 234 # At one point, the specific corruption caused by this test case was
 235 # causing a buffer overwrite. Although a crash was never demonstrated,
 236 # running this testcase under valgrind revealed the problem.
 237 do_test corrupt-6.1 {
 238   db close
 239   file delete -force test.db test.db-journal
 240   sqlite3 db test.db
 241   execsql {
 242     PRAGMA page_size = 1024; CREATE TABLE t1(x);
 243   }
 244
 245   # The root page of t1 is 1024 bytes in size. The header is 8 bytes, and
 246   # each of the cells inserted by the following INSERT statements consume
 247   # 16 bytes (including the 2 byte cell-offset array entry). So the page
 248   # can contain up to 63 cells.
 249   for {set i 0} {$i < 63} {incr i} {
 250     execsql { INSERT INTO t1 VALUES( randomblob(10) ) }
 251   }
 252
 253   # Free the cell stored right at the end of the page (at offset pgsz-14).
 254   execsql { DELETE FROM t1 WHERE rowid=1 }
 255   set rootpage [db one {SELECT rootpage FROM sqlite_master WHERE name = 't1'}]
 256   db close
 257
 258   set offset [expr ($rootpage * 1024)-14+2]
 259   hexio_write test.db $offset 00FF
 260   sqlite3 db test.db
 261
 262   catchsql { INSERT INTO t1 VALUES( randomblob(10) ) }
 263 } {1 {database disk image is malformed}}
 264
 265 ifcapable oversize_cell_check {
 266   db close
 267   file delete -force test.db test.db-journal
 268   sqlite3 db test.db
 269   execsql {
 270     PRAGMA page_size = 1024; CREATE TABLE t1(x);
 271   }
 272
 273   do_test corrupt-7.1 {
 274     for {set i 0} {$i < 39} {incr i} {
 275       execsql {
 276         INSERT INTO t1 VALUES(X'000100020003000400050006000700080009000A');
 277       }
 278     }
 279   } {}
 280   db close
 281
 282   # Corrupt the root page of table t1 so that the first offset in the
 283   # cell-offset array points to the data for the SQL blob associated with
 284   # record (rowid=10). The root page still passes the checks in btreeInitPage(),
 285   # because the start of said blob looks like the start of a legitimate
 286   # page cell.
 287   #
 288   # Test case cc-2 overwrites the blob so that it no longer looks like a
 289   # real cell. But, by the time it is overwritten, btreeInitPage() has already
 290   # initialized the root page, so no corruption is detected.
 291   #
 292   # Test case cc-3 inserts an extra record into t1, forcing balance-deeper
 293   # to run. After copying the contents of the root page to the new child,
 294   # btreeInitPage() is called on the child. This time, it detects corruption
 295   # (because the start of the blob associated with the (rowid=10) record
 296   # no longer looks like a real cell). At one point the code assumed that
 297   # detecting corruption was not possible at that point, and an assert() failed.
 298   #
 299   set fd [open test.db r+]
 300   fconfigure $fd -translation binary -encoding binary
 301   seek $fd [expr 1024+8]
 302   puts -nonewline $fd "\x03\x14"
 303   close $fd
 304
 305   sqlite3 db test.db
 306   do_test corrupt-7.2 {
 307     execsql {
 308       UPDATE t1 SET x = X'870400020003000400050006000700080009000A'
 309       WHERE rowid = 10;
 310     }
 311   } {}
 312   do_test corrupt-7.3 {
 313     catchsql {
 314       INSERT INTO t1 VALUES(X'000100020003000400050006000700080009000A');
 315     }
 316   } {1 {database disk image is malformed}}
 317 }
 318
 319 db close
 320 file delete -force test.db test.db-journal
 321 do_test corrupt-8.1 {
 322   sqlite3 db test.db
 323   execsql {
 324     PRAGMA page_size = 1024;
 325     PRAGMA secure_delete = on;
 326     PRAGMA auto_vacuum = 0;
 327     CREATE TABLE t1(x INTEGER PRIMARY KEY, y);
 328     INSERT INTO t1 VALUES(5, randomblob(1900));
 329   }
 330
 331   hexio_write test.db 2044 [hexio_render_int32 2]
 332   hexio_write test.db 24   [hexio_render_int32 45]
 333
 334   catchsql { INSERT OR REPLACE INTO t1 VALUES(5, randomblob(1900)) }
 335 } {1 {database disk image is malformed}}
 336
 337 db close
 338 file delete -force test.db test.db-journal
 339 do_test corrupt-8.2 {
 340   sqlite3 db test.db
 341   execsql {
 342     PRAGMA page_size = 1024;
 343     PRAGMA secure_delete = on;
 344     PRAGMA auto_vacuum = 0;
 345     CREATE TABLE t1(x INTEGER PRIMARY KEY, y);
 346     INSERT INTO t1 VALUES(5, randomblob(900));
 347     INSERT INTO t1 VALUES(6, randomblob(900));
 348   }
 349
 350   hexio_write test.db 2047 FF
 351   hexio_write test.db 24   [hexio_render_int32 45]
 352
 353   catchsql { INSERT INTO t1 VALUES(4, randomblob(1900)) }
 354 } {1 {database disk image is malformed}}
 355
 356 finish_test