• Re: How The FBI Finds Your DELETED Files

    From Alan@nuh-uh@nope.com to alt.comp.os.windows-11,alt.privacy.anon-server,misc.phone.mobile.iphone on Sun Sep 27 11:56:04 2026
    From Newsgroup: alt.privacy.anon-server

    On 2026-09-22 11:22, Paul wrote:
    On Mon, 9/21/2026 4:12 PM, Nomen Nescio wrote:


    Did you ever experiement with this?

    fsutil file createnew zeroes.txt 100000000 (Any size you want etc.)

    Creates a file full of zeroes.


    *********************** CoPilot Answer *****************************
    **Short answer:** **`fsutil file createnew` does *not* write 93rC>GB of zeroes.**
    It finishes instantly because it uses an NTFS metadata trick:
    **it sets the file *valid data length* and *end-of-file* in the MFT
    without actually writing the data blocks.** NTFS then *logically* treats
    the file as containing zeroes, but the disk blocks are not physically written.

    This is why creating a 93rC>GB file appears instantaneous.

    How does NTFS "then *logically* treat[] the file as containing zeroes"

    If one then reads the file, how does NTFS know not to read the actual
    data that is IN those blocks?
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Paul@nospam@needed.invalid to alt.comp.os.windows-11,alt.privacy.anon-server,misc.phone.mobile.iphone on Sun Sep 27 15:51:37 2026
    From Newsgroup: alt.privacy.anon-server

    On Sun, 9/27/2026 2:56 PM, Alan wrote:
    On 2026-09-22 11:22, Paul wrote:
    On Mon, 9/21/2026 4:12 PM, Nomen Nescio wrote:


    Did you ever experiement with this?

    fsutil file createnew zeroes.txt 100000000 (Any size you want etc.)

    Creates a file full of zeroes.


    *********************** CoPilot Answer *****************************
    **Short answer:** **`fsutil file createnew` does *not* write 93rC>GB of zeroes.**
    It finishes instantly because it uses an NTFS metadata trick:
    **it sets the file *valid data length* and *end-of-file* in the MFT
    without actually writing the data blocks.** NTFS then *logically* treats
    the file as containing zeroes, but the disk blocks are not physically written.

    This is why creating a 93rC>GB file appears instantaneous.


    How does NTFS "then *logically* treat[] the file as containing zeroes"

    If one then reads the file, how does NTFS know not to read the actual data that is IN those blocks?

    https://superuser.com/questions/1619084/what-does-the-command-fsutil-file-createnew-really-do

    "The filesystem may keep two separate pointers - the 'end of file' as well as 'end of
    valid data'. This is explicitly how NTFS works in Windows.

    You can call SetEndOfFile() (corresponding to Linux ftruncate()) to create a large
    file with no data, and the space between "end of valid data" and "end of file" will
    automatically return all 0x00 bytes when read.

    (Privileged accounts can actually use the SetFileValidData() call to force the OS to
    return data that is already on disk, but it's not a commonly used operation.) "
    Paul
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Alan@nuh-uh@nope.com to alt.comp.os.windows-11,alt.privacy.anon-server,misc.phone.mobile.iphone on Sun Sep 27 14:28:32 2026
    From Newsgroup: alt.privacy.anon-server

    On 2026-09-27 12:51, Paul wrote:
    On Sun, 9/27/2026 2:56 PM, Alan wrote:
    On 2026-09-22 11:22, Paul wrote:
    On Mon, 9/21/2026 4:12 PM, Nomen Nescio wrote:


    Did you ever experiement with this?

    fsutil file createnew zeroes.txt 100000000 (Any size you want etc.)

    Creates a file full of zeroes.


    *********************** CoPilot Answer *****************************
    **Short answer:** **`fsutil file createnew` does *not* write 93rC>GB of zeroes.**
    It finishes instantly because it uses an NTFS metadata trick:
    **it sets the file *valid data length* and *end-of-file* in the MFT
    without actually writing the data blocks.** NTFS then *logically* treats >>> the file as containing zeroes, but the disk blocks are not physically written.

    This is why creating a 93rC>GB file appears instantaneous.


    How does NTFS "then *logically* treat[] the file as containing zeroes"

    If one then reads the file, how does NTFS know not to read the actual data that is IN those blocks?

    https://superuser.com/questions/1619084/what-does-the-command-fsutil-file-createnew-really-do

    "The filesystem may keep two separate pointers - the 'end of file' as well as 'end of
    valid data'. This is explicitly how NTFS works in Windows.

    You can call SetEndOfFile() (corresponding to Linux ftruncate()) to create a large
    file with no data, and the space between "end of valid data" and "end of file" will
    automatically return all 0x00 bytes when read.

    (Privileged accounts can actually use the SetFileValidData() call to force the OS to
    return data that is already on disk, but it's not a commonly used operation.)
    "
    Paul

    And none of that will protect you if someone does a raw scan of the
    drive's blocks.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Paul@nospam@needed.invalid to alt.comp.os.windows-11,alt.privacy.anon-server,misc.phone.mobile.iphone on Sun Sep 27 21:01:29 2026
    From Newsgroup: alt.privacy.anon-server

    On Sun, 9/27/2026 5:28 PM, Alan wrote:
    On 2026-09-27 12:51, Paul wrote:
    On Sun, 9/27/2026 2:56 PM, Alan wrote:
    On 2026-09-22 11:22, Paul wrote:
    On Mon, 9/21/2026 4:12 PM, Nomen Nescio wrote:


    Did you ever experiement with this?

    fsutil file createnew zeroes.txt 100000000 (Any size you want etc.)

    Creates a file full of zeroes.


    *********************** CoPilot Answer *****************************
    **Short answer:** **`fsutil file createnew` does *not* write 93rC>GB of zeroes.**
    It finishes instantly because it uses an NTFS metadata trick:
    **it sets the file *valid data length* and *end-of-file* in the MFT
    without actually writing the data blocks.** NTFS then *logically* treats >>>> the file as containing zeroes, but the disk blocks are not physically written.

    This is why creating a 93rC>GB file appears instantaneous.


    How does NTFS "then *logically* treat[] the file as containing zeroes"

    If one then reads the file, how does NTFS know not to read the actual data that is IN those blocks?

    https://superuser.com/questions/1619084/what-does-the-command-fsutil-file-createnew-really-do

    "The filesystem may keep two separate pointers - the 'end of file' as well as 'end of
    -a valid data'. This is explicitly how NTFS works in Windows.

    -a You can call SetEndOfFile() (corresponding to Linux ftruncate()) to create a large
    -a file with no data, and the space between "end of valid data" and "end of file" will
    -a automatically return all 0x00 bytes when read.

    -a (Privileged accounts can actually use the SetFileValidData() call to force the OS to
    -a return data that is already on disk, but it's not a commonly used operation.)
    "
    -a-a-a Paul

    And none of that will protect you if someone does a raw scan of the drive's blocks.

    Which is what I did, to prove the command could
    not erase anything in zero microseconds. Ran HxD
    as Administrator, and then the old data (the real
    material on those sectors) showed through.

    Even when a command takes finite time, you still have
    to verify whether it was doing "reads" or "writes"
    in the time interval. A format that does a bad block
    scan, takes a finite time, but does not erase much
    of anything for you. The writes would include a
    new $MFT, but much of the rest of the disk activity
    is reads.

    If you change the encryption key on a drive, that achieves
    "erasure" instantly, but that assumes the previous key cannot
    be recovered. And we don't know how keys are handled in there.
    This capability was used by ransomware at one point.

    Paul

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Nomen Nescio@nobody@dizum.com to alt.comp.os.windows-11, alt.privacy.anon-server, misc.phone.mobile.iphone on Mon Sep 28 06:37:49 2026
    From Newsgroup: alt.privacy.anon-server

    On 27 Sep 2026, Alan <nuh-uh@nope.com> posted some news:119c1q0$1oso7$1@dont-email.me:

    On 2026-09-27 12:51, Paul wrote:
    On Sun, 9/27/2026 2:56 PM, Alan wrote:
    On 2026-09-22 11:22, Paul wrote:
    On Mon, 9/21/2026 4:12 PM, Nomen Nescio wrote:


    Did you ever experiement with this?

    fsutil file createnew zeroes.txt 100000000 (Any size you want
    etc.)

    Creates a file full of zeroes.


    *********************** CoPilot Answer
    ***************************** **Short answer:** **`fsutil file
    createnew` does *not* write 93rC>GB of zeroes.** It finishes
    instantly because it uses an NTFS metadata trick: **it sets the
    file *valid data length* and *end-of-file* in the MFT without
    actually writing the data blocks.** NTFS then *logically* treats
    the file as containing zeroes, but the disk blocks are not
    physically written.

    This is why creating a 93rC>GB file appears instantaneous.


    How does NTFS "then *logically* treat[] the file as containing
    zeroes"

    If one then reads the file, how does NTFS know not to read the
    actual data that is IN those blocks?

    https://superuser.com/questions/1619084/what-does-the-command-fsutil-
    f
    ile-createnew-really-do

    "The filesystem may keep two separate pointers - the 'end of file' as
    well as 'end of
    valid data'. This is explicitly how NTFS works in Windows.

    You can call SetEndOfFile() (corresponding to Linux ftruncate()) to
    create a large file with no data, and the space between "end of
    valid data" and "end of file" will automatically return all 0x00
    bytes when read.

    (Privileged accounts can actually use the SetFileValidData() call
    to force the OS to return data that is already on disk, but it's
    not a commonly used operation.)
    "
    Paul

    And none of that will protect you if someone does a raw scan of the
    drive's blocks.

    That depends if anything was ever there.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Alan@nuh-uh@nope.com to alt.comp.os.windows-11,alt.privacy.anon-server,misc.phone.mobile.iphone on Fri Oct 2 23:18:56 2026
    From Newsgroup: alt.privacy.anon-server

    On 2026-09-27 21:37, Nomen Nescio wrote:
    On 27 Sep 2026, Alan <nuh-uh@nope.com> posted some news:119c1q0$1oso7$1@dont-email.me:

    On 2026-09-27 12:51, Paul wrote:
    On Sun, 9/27/2026 2:56 PM, Alan wrote:
    On 2026-09-22 11:22, Paul wrote:
    On Mon, 9/21/2026 4:12 PM, Nomen Nescio wrote:


    Did you ever experiement with this?

    fsutil file createnew zeroes.txt 100000000 (Any size you want
    etc.)

    Creates a file full of zeroes.


    *********************** CoPilot Answer
    ***************************** **Short answer:** **`fsutil file
    createnew` does *not* write 93rC>GB of zeroes.** It finishes
    instantly because it uses an NTFS metadata trick: **it sets the
    file *valid data length* and *end-of-file* in the MFT without
    actually writing the data blocks.** NTFS then *logically* treats
    the file as containing zeroes, but the disk blocks are not
    physically written.

    This is why creating a 93rC>GB file appears instantaneous.


    How does NTFS "then *logically* treat[] the file as containing
    zeroes"

    If one then reads the file, how does NTFS know not to read the
    actual data that is IN those blocks?

    https://superuser.com/questions/1619084/what-does-the-command-fsutil-
    f
    ile-createnew-really-do

    "The filesystem may keep two separate pointers - the 'end of file' as
    well as 'end of
    valid data'. This is explicitly how NTFS works in Windows.

    You can call SetEndOfFile() (corresponding to Linux ftruncate()) to
    create a large file with no data, and the space between "end of
    valid data" and "end of file" will automatically return all 0x00
    bytes when read.

    (Privileged accounts can actually use the SetFileValidData() call
    to force the OS to return data that is already on disk, but it's
    not a commonly used operation.)
    "
    Paul

    And none of that will protect you if someone does a raw scan of the
    drive's blocks.

    That depends if anything was ever there.


    The whole point of the thread is the assumption that there IS something
    there.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Nomen Nescio@nobody@dizum.com to alt.comp.os.windows-11, alt.privacy.anon-server, misc.phone.mobile.iphone on Sat Oct 3 11:20:18 2026
    From Newsgroup: alt.privacy.anon-server

    On 02 Oct 2026, Alan <nuh-uh@nope.com> posted some news:119q6og$2ot8f$1@dont-email.me:

    On 2026-09-27 21:37, Nomen Nescio wrote:
    On 27 Sep 2026, Alan <nuh-uh@nope.com> posted some
    news:119c1q0$1oso7$1@dont-email.me:

    On 2026-09-27 12:51, Paul wrote:
    On Sun, 9/27/2026 2:56 PM, Alan wrote:
    On 2026-09-22 11:22, Paul wrote:
    On Mon, 9/21/2026 4:12 PM, Nomen Nescio wrote:


    Did you ever experiement with this?

    fsutil file createnew zeroes.txt 100000000 (Any size you want
    etc.)

    Creates a file full of zeroes.


    *********************** CoPilot Answer
    ***************************** **Short answer:** **`fsutil file
    createnew` does *not* write 93rC>GB of zeroes.** It finishes
    instantly because it uses an NTFS metadata trick: **it sets the
    file *valid data length* and *end-of-file* in the MFT without
    actually writing the data blocks.** NTFS then *logically* treats
    the file as containing zeroes, but the disk blocks are not
    physically written.

    This is why creating a 93rC>GB file appears instantaneous.


    How does NTFS "then *logically* treat[] the file as containing
    zeroes"

    If one then reads the file, how does NTFS know not to read the
    actual data that is IN those blocks?

    https://superuser.com/questions/1619084/what-does-the-command-fsutil
    -
    f
    ile-createnew-really-do

    "The filesystem may keep two separate pointers - the 'end of file'
    as well as 'end of
    valid data'. This is explicitly how NTFS works in Windows.

    You can call SetEndOfFile() (corresponding to Linux ftruncate())
    to create a large file with no data, and the space between "end
    of valid data" and "end of file" will automatically return all
    0x00 bytes when read.

    (Privileged accounts can actually use the SetFileValidData()
    call to force the OS to return data that is already on disk, but
    it's not a commonly used operation.)
    "
    Paul

    And none of that will protect you if someone does a raw scan of the
    drive's blocks.

    That depends if anything was ever there.


    The whole point of the thread is the assumption that there IS
    something there.

    Not between your ears there isn't.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Alan@nuh-uh@nope.com to alt.comp.os.windows-11,alt.privacy.anon-server,misc.phone.mobile.iphone on Mon Oct 5 12:37:28 2026
    From Newsgroup: alt.privacy.anon-server

    On 2026-10-03 02:20, Nomen Nescio wrote:
    On 02 Oct 2026, Alan <nuh-uh@nope.com> posted some news:119q6og$2ot8f$1@dont-email.me:

    On 2026-09-27 21:37, Nomen Nescio wrote:
    On 27 Sep 2026, Alan <nuh-uh@nope.com> posted some
    news:119c1q0$1oso7$1@dont-email.me:

    On 2026-09-27 12:51, Paul wrote:
    On Sun, 9/27/2026 2:56 PM, Alan wrote:
    On 2026-09-22 11:22, Paul wrote:
    On Mon, 9/21/2026 4:12 PM, Nomen Nescio wrote:


    Did you ever experiement with this?

    fsutil file createnew zeroes.txt 100000000 (Any size you want
    etc.)

    Creates a file full of zeroes.


    *********************** CoPilot Answer
    ***************************** **Short answer:** **`fsutil file
    createnew` does *not* write 93rC>GB of zeroes.** It finishes
    instantly because it uses an NTFS metadata trick: **it sets the
    file *valid data length* and *end-of-file* in the MFT without
    actually writing the data blocks.** NTFS then *logically* treats >>>>>>> the file as containing zeroes, but the disk blocks are not
    physically written.

    This is why creating a 93rC>GB file appears instantaneous.


    How does NTFS "then *logically* treat[] the file as containing
    zeroes"

    If one then reads the file, how does NTFS know not to read the
    actual data that is IN those blocks?

    https://superuser.com/questions/1619084/what-does-the-command-fsutil >>>>> -
    f
    ile-createnew-really-do

    "The filesystem may keep two separate pointers - the 'end of file'
    as well as 'end of
    valid data'. This is explicitly how NTFS works in Windows.

    You can call SetEndOfFile() (corresponding to Linux ftruncate()) >>>>> to create a large file with no data, and the space between "end
    of valid data" and "end of file" will automatically return all
    0x00 bytes when read.

    (Privileged accounts can actually use the SetFileValidData()
    call to force the OS to return data that is already on disk, but >>>>> it's not a commonly used operation.)
    "
    Paul

    And none of that will protect you if someone does a raw scan of the
    drive's blocks.

    That depends if anything was ever there.


    The whole point of the thread is the assumption that there IS
    something there.

    Not between your ears there isn't.


    I'm sure you think that's very witty.
    --- Synchronet 3.22a-Linux NewsLink 1.2