myCSharp.de - DIE C# und .NET Community
Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 
 | Suche | FAQ

» Hauptmenü
myCSharp.de
» Startseite
» Forum
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Suche
» Regeln
» Wie poste ich richtig?
» Forum-FAQ

Mitglieder
» Liste / Suche
» Wer ist wo online?

Ressourcen
» openbook: Visual C#
» openbook: OO
» Microsoft Docs

Team
» Kontakt
» Übersicht
» Wir über uns

» myCSharp.de Diskussionsforum
Du befindest Dich hier: Community-Index » Diskussionsforum » Knowledge Base » Artikel » [Artikel] Alternative NTFS Datenströme
Letzter Beitrag | Erster ungelesener Beitrag Druckvorschau | Thema zu Favoriten hinzufügen

Antwort erstellen
Zum Ende der Seite springen  

[Artikel] Alternative NTFS Datenströme

 
Autor
Beitrag « Vorheriges Thema | Nächstes Thema »
egrath egrath ist männlich
myCSharp.de-Mitglied

avatar-2119.jpg


Dabei seit: 24.07.2005
Beiträge: 871
Entwicklungsumgebung: MonoDevelop, NetBeans, Vi
Herkunft: Österreich / Steyr


egrath ist offline

[Artikel] Alternative NTFS Datenströme

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Alternative NTFS Datenströme

Seit mit Windows NT 3.1 das erste mal das NTFS Dateisystem auf den Markt kam, gibt es bei diesem ein Feature welches bis datto aus diversen Gründen nur sehr spärliche Beachtung gefunden hat: Die alternativen Datenströme.

Auf einem NTFS Datenträger besteht eine Datei aus sogenannten Datenströmen (im folgenden nur mehr Streams genannt). Derer kann eine Datei eine beliebige Anzahl besitzen. Nur der erste Stream allerdings ist für den Endbenutzer direkt sichtbar, alle anderen Streams müssen programmatisch angesprochen werden. Auch wird mit normalen Benutzermitteln immer nur die Grösse des ersten Streams angezeigt.

Grafisch gesehen kann man sich eine Datei auf einem NTFS Datenträger also folgendermassen vorstellen:

Code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
+----------------------------------------+
| Direkt sichtbar +---------------------+|
|                 | Unnamed Stream      ||
|                 +---------------------+|
|----------------------------------------|
| Indirekt        +---------------------+|
| sichtbar        | Stream 1            ||
|                 +---------------------+|
|                          ...           |
|                 +---------------------+|
|                 | Stream n            ||
|                 +---------------------+|
+----------------------------------------+

Ansprechen der alternativen Streams

Stream werden grundsätzlich dadurch angesprochen, dass an den Namen der Datei ein Doppelpunkt und anschliessend der Name des Streams angegeben wird. Beispielsweise wird mittels "test.txt:MeinStream" auf den benannten Stream "MeinStream" der Datei "test.txt" zugegriffen. Auf der Kommandozeile können wir dies zu Demonstrationszwecken einfach testen:

Code:
1:
2:
3:
4:
C:\>echo Hallo > test.txt
C:\>type test.txt
Hallo
C:\>echo Das ist ein test > test.txt:MeinStream

Wenn wir die Datei nun öffnen (beispielsweise mit Wordpad) dann sehen wir nur den Text "Hallo". Öffnen wir allerdings "test.txt:MeinStream", so sehen wir den Inhalt des benannten Streams "MeinStream". Dies ist keine Applikationsspezifische Sache, sondern wird von den grundlegenden Win32-API Funktionen (insbesondere CreateFile) zur verfügung gestellt.

Im .NET Framework (Version 1.1 und 2.0) ist es leider nicht möglich, direkt auf Streams zuzugreifen, da die entsprechenden Methoden dies nicht unterstützen (Es wird überprüft ob der Dateiname gültige Zeichen enthält, der Doppelpunkt gehört anscheinend beim Framework nicht dazu - eine Exception wird geworfen). Wir müssen daher einen umweg gehen und das File mittels der von der Win32-API zur verfügung gestellten CreateFile Funktion öffnen und den zurückgelieferten Handle für das öffnen mit den .NET Methoden benutzen.

Schreiben und Lesen von Streams unter C#

C#-Code:
using System;
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

namespace StreamTest
{
    class Program
    {
        [DllImport( "kernel32.dll", SetLastError=true )]
        private static extern IntPtr CreateFile( string fileName, FILE_ACCESS_RIGHTS access, FileShare share, int securityAttributes,
                                                 FileMode creation, FILE_FLAGS flags, IntPtr templateFile );

        [DllImport( "kernel32.dll", SetLastError=true )]
        private static extern bool CloseHandle( IntPtr handle );

        public static void Main( string[] args )
        {
            // Schreiben des Streams
            IntPtr fileHandle = CreateFile( "myFile.txt:myStream1", FILE_ACCESS_RIGHTS.GENERIC_WRITE, FileShare.Write, 0, FileMode.Create, 0, IntPtr.Zero );
            TextWriter writer = new StreamWriter( new FileStream( new SafeFileHandle( fileHandle, true ), FileAccess.Write ));

            writer.WriteLine( "Ich bin ein Stream" );
            writer.Close();
            CloseHandle( fileHandle );

            // Lesen des Streams
            fileHandle = CreateFile( "myFile.txt:myStream1", FILE_ACCESS_RIGHTS.GENERIC_READ, FileShare.Read, 0, FileMode.Open, 0, IntPtr.Zero );
            TextReader reader = new StreamReader( new FileStream( new SafeFileHandle( fileHandle, true ), FileAccess.Read ));

            Console.Out.WriteLine( reader.ReadToEnd() );
            reader.Close();
            CloseHandle( fileHandle );
        }

        private enum FILE_ACCESS_RIGHTS : uint
        {
            GENERIC_READ = 0x80000000,
            GENERIC_WRITE = 0x40000000
        }

        private enum FILE_FLAGS : uint
        {
            WriteThrough = 0x80000000,
            Overlapped = 0x40000000,
            NoBuffering = 0x20000000,
            RandomAccess = 0x10000000,
            SequentialScan = 0x8000000,
            DeleteOnClose = 0x4000000,
            BackupSemantics = 0x2000000,
            PosixSemantics = 0x1000000,
            OpenReparsePoint = 0x200000,
            OpenNoRecall = 0x100000
        }
    }
}

Anzeigen der Streams einer Datei

Wenn wir wissen wie die benannten Streams einer Datei heissen, so haben wir kein Problem mit dem ansprechen dieser. Nur das herausfinden ob und welche Streams eine Datei hat ist eine Sache welche mit Bordeigenen Windows-Mitteln nicht so einfach zu bewerkstelligen ist. Grundsätzlich gibt es zwei möglichkeiten:
  • API Funktion NtQueryInformationFile
  • API Funktion BackupRead und BackupSeek
Wobei die erste Methode nicht zu empfehlen ist, da es sich dabei um einen nicht dokumentieren Systemcall handelt. Letzterer hat dafür den Nachteil dass man für das eruieren der Streamnamen die komplette Datei lesen muss. Erst mit Windows Vista wird eine API Funktionalität eingeführt mit der diese Lücke geschlossen wird (FindFirstStreamW und FindNextStreamW)

Für unser Beispiel werden wir auf die BackupRead Methode zurückgreifen und damit folgenden Informationen eruieren:
  • Name des Streams
  • Type des Streams
  • Grösse des Streams
Eruieren der Streams einer Datei unter C#

C#-Code:
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

namespace AlternateDataStreams
{
    public class Program
    {
        public static void Main( string[] args )
        {
            if( args.Length < 1 ) return;

            List<DataStreamInfo> streams = EnumerateDataStreams.GetFileStreams( args[0] );
            if( streams.Count == 0 )
            {
                Console.Out.WriteLine( "File [{0}] has no alternate Data Streams", args[0] );
            }
            else
            {
                foreach( DataStreamInfo s in streams )
                {
                    Console.Out.WriteLine( "Name: {0}, Length = {1}, Type = {2}", s.StreamName, s.StreamSize, s.StreamType );
                }
            }
        }
    }

    internal static class EnumerateDataStreams
    {
        [DllImport("kernel32.dll")]
        private static extern bool BackupRead(SafeFileHandle handle, IntPtr pBuffer, int lBytes, ref int lRead, bool bAbort, bool security, ref int context);

        [DllImport("kernel32.dll")]
        private static extern bool BackupRead(SafeFileHandle handle, ref WIN32_STREAM_ID pBuffer, int lBytes, ref int lRead, bool bAbort, bool security, ref int context);

        [DllImport( "kernel32.dll" )]
        private static extern bool BackupSeek( SafeFileHandle handle, int dwLowBytesToSeek, int dwHighBytesToSeek, ref int dwLow, ref int dwHigh, ref int context );

        private struct LARGE_INTEGER
        {
            public int Low;
            public int High;

            public long QuadPart()
            {
                return (long)High * 4294967296 + (long)Low;
            }
        }

        private struct WIN32_STREAM_ID
        {
            public int streamId;
            public int streamAttributes;
            public LARGE_INTEGER size;
            public int streamNameSize;
        }

        private enum StreamType : int
        {
            BACKUP_ALTERNATE_DATA = 0x00000004,
            BACKUP_DATA = 0x0000001,
            BACKUP_EA_DATA = 0x00000002,
            BACKUP_LINK = 0x00000005,
            BACKUP_OBJECT_ID = 0x00000007,
            BACKUP_PROPERTY_DATA = 0x00000006,
            BACKUP_REPARSE_DATA = 0x00000008,
            BACKUP_SECURITY_DATA = 0x00000003,
            BACKUP_SPARSE_BLOCK = 0x00000009
        }

        public static List<DataStreamInfo> GetFileStreams( string fileName )
        {
            List<DataStreamInfo> streams = new List<DataStreamInfo>();
            FileStream fileStream = new FileStream( fileName, FileMode.Open );

            try
            {
                WIN32_STREAM_ID streamId = new WIN32_STREAM_ID();
                int streamHeaderSize  = Marshal.SizeOf( streamId );
                int context = 0;
                bool hasMore = true;

                while( hasMore )
                {
                    int bytesRead = 0;
                    hasMore = BackupRead( fileStream.SafeFileHandle, ref streamId, streamHeaderSize, ref bytesRead, false, false, ref context);

                    if( hasMore && bytesRead == streamHeaderSize )
                    {
                        if( streamId.streamNameSize > 0 )
                        {
                            bytesRead = 0;
                            IntPtr pName = Marshal.AllocHGlobal( streamId.streamNameSize );
                            try
                            {
                                BackupRead(fileStream.SafeFileHandle, pName, streamId.streamNameSize, ref bytesRead, false, false, ref context);
                                char[] bName = new char[streamId.streamNameSize];
                                Marshal.Copy( pName, bName, 0, streamId.streamNameSize );

                                string sName = new string(bName);
                                int index = sName.IndexOf( ':', 1);
                                if( index > -1) sName = sName.Substring( 1, index -1 );

                                DataStreamInfo streamInfo = new DataStreamInfo();
                                streamInfo.StreamName = sName;
                                streamInfo.StreamSize = streamId.size.QuadPart();
                                switch( streamId.streamId )
                                {
                                    case ( int ) StreamType.BACKUP_ALTERNATE_DATA:
                                        streamInfo.StreamType = "Alternative Data Stream";
                                        break;

                                    case ( int ) StreamType.BACKUP_DATA:
                                        streamInfo.StreamType = "Standard Data";
                                        break;

                                    case ( int ) StreamType.BACKUP_EA_DATA:
                                        streamInfo.StreamType = "Extended attribute Data";
                                        break;

                                    case ( int ) StreamType.BACKUP_LINK:
                                        streamInfo.StreamType = "Hard link information";
                                        break;

                                    case ( int ) StreamType.BACKUP_OBJECT_ID:
                                        streamInfo.StreamType = "Object identifiers";
                                        break;

                                    case ( int ) StreamType.BACKUP_PROPERTY_DATA:
                                        streamInfo.StreamType = "Property data";
                                        break;

                                    case ( int ) StreamType.BACKUP_REPARSE_DATA:
                                        streamInfo.StreamType = "Reparse points";
                                        break;

                                    case ( int ) StreamType.BACKUP_SECURITY_DATA:
                                        streamInfo.StreamType = "Security descriptor data";
                                        break;

                                    case ( int ) StreamType.BACKUP_SPARSE_BLOCK:
                                        streamInfo.StreamType = "Sparse file";
                                        break;
                                }

                                streams.Add( streamInfo );
                            }
                            finally
                            {
                                Marshal.FreeHGlobal(pName);

                            }
                        }

                        int low = 0;
                        int high = 0;
                        BackupSeek( fileStream.SafeFileHandle, streamId.size.Low, streamId.size.High, ref low, ref high, ref context );
                    }
                    else
                    {
                        break;
                    }
                }
            }
            catch
            {
                return null;
            }
            finally
            {
                fileStream.Close();
            }

            return streams;
        }
    }

    internal struct DataStreamInfo
    {
        private string m_StreamName;
        private long m_StreamSize;
        private string m_StreamType;

        public string StreamType
        {
            get
            {
                return m_StreamType;
            }

            set
            {
                m_StreamType = value;
            }
        }

        public string StreamName
        {
            get
            {
                return m_StreamName;
            }

            set
            {
                m_StreamName = value;
            }
        }

        public long StreamSize
        {
            get
            {
                return m_StreamSize;
            }

            set
            {
                m_StreamSize = value;
            }
        }
    }
}

/edit: Die beiden Sourcen sind als ZIP File im anhang enthalten
/edit: Ein paar Tippfehler beseitigt.


Dateianhang:
unknown ads_source.zip (3 KB, 1.277 mal heruntergeladen)

Dieser Beitrag wurde 2 mal editiert, zum letzten Mal von egrath am 25.10.2006 10:59.

25.10.2006 08:11 Beiträge des Benutzers | zu Buddylist hinzufügen
Timur Zanagar Timur Zanagar ist männlich
myCSharp.de-Mitglied

avatar-3412.jpg


Dabei seit: 10.11.2004
Beiträge: 1.457


Timur Zanagar ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hi,

Ich finde deinen Artikel sehr interessant. Möchte aber wissen in welchen Bereichen dies verwendet wird? Welchen nutzen haben die Datenströme?

Vielen Dank im Voraus.
25.10.2006 08:39 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Fabian Fabian ist männlich
myCSharp.de-Mitglied

avatar-1590.jpg


Dabei seit: 09.12.2004
Beiträge: 1.985
Entwicklungsumgebung: Visual Studio 2010
Herkunft: Dortmund


Fabian ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo zusammen,

ich schließe mich der Frage von burning snow an, da mir das auch noch nicht ganz klar ist. Aber sehr interessanter Artikel!


Gruß,
Fabian
25.10.2006 08:45 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
egrath egrath ist männlich
myCSharp.de-Mitglied

avatar-2119.jpg


Dabei seit: 24.07.2005
Beiträge: 871
Entwicklungsumgebung: MonoDevelop, NetBeans, Vi
Herkunft: Österreich / Steyr

Themenstarter Thema begonnen von egrath

egrath ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo burning snow,

beispielsweise werden Datenströme dafür benutzt um zusätzliche Metadaten für Dateien zu speichern - Windows nutzt dies unter anderem dafür wenn du Informationen zu einer Datei speicherst (Eigenschaften einer Datei->Summary, dann sachen wie Author usw eintragen). Wird dann als Named Stream "SummaryInformation" zu einer Datei gespeichert.

Desweiteren könnte man es beispielsweise dazu benutzen Informationen in einer Datei zu "verstecken": Neue Datei mit 0 Bytes anlegen und in alternativen Stream was reinschreiben. Mit herkömmlichen Mitteln sieht man nur eine leere Datei wenn man nicht weiss dass da ein Stream dranhängt (Da im Explorer nur die Grösse des ersten, unnamed Streams angezeigt wird)

Grüsse, Egon

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von egrath am 25.10.2006 08:47.

25.10.2006 08:46 Beiträge des Benutzers | zu Buddylist hinzufügen
Timur Zanagar Timur Zanagar ist männlich
myCSharp.de-Mitglied

avatar-3412.jpg


Dabei seit: 10.11.2004
Beiträge: 1.457


Timur Zanagar ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Vielen Dank für die Aufklärung. Genau das hat mir noch gefehlt an Infos.
25.10.2006 08:53 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
MagicAndre1981 MagicAndre1981 ist männlich
myCSharp.de-Mitglied

avatar-2623.jpg


Dabei seit: 16.05.2005
Beiträge: 906
Entwicklungsumgebung: Visual Studio 2005 Prof/ #d2.1
Herkunft: Nordhausen


MagicAndre1981 ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Kaspersky legt auch ADS an, damit es schneller scannen kann.

btw, kannst du die Sourcen anhängen, ist sonst so umstaänlich mit dem Kopieren.
25.10.2006 09:22 Beiträge des Benutzers | zu Buddylist hinzufügen
Borg
myCSharp.de-Mitglied

Dabei seit: 23.08.2006
Beiträge: 1.529
Entwicklungsumgebung: VS2005
Herkunft: Berlin, Germany


Borg ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

ADS werden auch für das Zonenmodell des IE genutzt. An eine Datei wird in einem ADS die Info gehangen, aus welcher Zone die Datei kommt. Dies verursacht dann die Dialogbox "Datei öffnen - Sicherheitswarnung".

Ansonsten muss man sich jedoch bewußt sein, dass ADS auch eine potentielle Sicherheitslücke ist. So konnten beim letzten Virenscannertest in der c't viele AVScanner nicht mit ADS umgehen.
Desweiteren kann weder der Explorer noch der dir-Befehl ADS anzeigen.
Daher kann ich auch mit einer für den Nutzer scheinbar 1Byte großen Datei die gesamte Festplatte füllen.
Also: acht geben, wofür man die ADS nutzt und dem Nutzer immer (spätestens bei der Deinstallation) die Möglichkeit gewähren, alle erzeugten ADS auch wieder zu entfernen.


mycsharp.de  Moderationshinweis von herbivore (25.10.2012 08:19):

Zitat:
Desweiteren kann weder der Explorer noch der dir-Befehl ADS anzeigen.

Diese Aussage war zum Zeitpunkt des Beitrags korrekt und bleibt es auch für Windows XP und Versionen davor. Ab Windows Vista gibt es bei beim Befehl dir die Option /r zum Anzeigen der ADS.

 
25.10.2006 13:52 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Timur Zanagar Timur Zanagar ist männlich
myCSharp.de-Mitglied

avatar-3412.jpg


Dabei seit: 10.11.2004
Beiträge: 1.457


Timur Zanagar ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

@Borg:
Da hast du wohl recht. Das kann auch nach hinten losgehen.
25.10.2006 14:05 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
nic4x4 nic4x4 ist männlich
myCSharp.de-Mitglied

avatar-1983.jpg


Dabei seit: 27.06.2006
Beiträge: 191
Entwicklungsumgebung: VS 2005 SE
Herkunft: NRW


nic4x4 ist offline Füge nic4x4 Deiner Kontaktliste hinzu

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Was passiert denn eigentlich, wenn man so eine Datei mit winrar packt?
Werden da auch die angehängten Daten mitgepackt oder nur der erste "Stream"?
29.10.2006 12:25 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Borg
myCSharp.de-Mitglied

Dabei seit: 23.08.2006
Beiträge: 1.529
Entwicklungsumgebung: VS2005
Herkunft: Berlin, Germany


Borg ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Schau dir mal den Advanced-Tab beim Erstellen von Archiven an...
29.10.2006 12:48 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
svenson svenson ist männlich
myCSharp.de-Mitglied

Dabei seit: 15.04.2005
Beiträge: 8.746
Entwicklungsumgebung: Visual Studio .NET 2003
Herkunft: Berlin


svenson ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Richtig übel: Befindet sich innerhalb einer EXE eine ADS-Exe, wird in den ProcessViewern nur der Hüllenname angezeigt. Hier ein schöner Artikel. Könnte auch erscheinen unter dem Namen: Viren und Trojaner verstecken leicht gemacht (und das nur mit der DOS-Box!):

 Hidden Threat: Alternate Data Streams

ADS gehört m.E. aus Windows entfernt oder transparent gemacht (Explorer, leicht zu nutzende API, etc.).

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von svenson am 29.10.2006 23:51.

29.10.2006 23:50 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Borg
myCSharp.de-Mitglied

Dabei seit: 23.08.2006
Beiträge: 1.529
Entwicklungsumgebung: VS2005
Herkunft: Berlin, Germany


Borg ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Bei mir zeigt der Taskmanager den vollen Namen an (also mit ADS).
30.10.2006 00:04 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Zwischen diesen beiden Beiträgen liegen mehr als 5 Jahre.
herbivore
myCSharp.de-Poweruser/ Experte

avatar-2627.gif


Dabei seit: 11.01.2005
Beiträge: 49.461
Entwicklungsumgebung: csc/nmake (nothing is faster)
Herkunft: Berlin


herbivore ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Hallo zusammen,

es gibt folgendes Statement von Microsoft zum Support von ADS in Windows 8:

Zitat von Microsoft:
The file system that you normally use is NTFS.

Alternate data streams are still supported in NTFS for Windows 8.

The new file system that we will also be providing in Windows 8 is ReFS.

ReFS doesn't support Alternate data streams.

Außerdem sollte man wissen, das ADS beim Kopieren auf FAT32 verloren gehen, also nicht mit kopiert werden, weil FAT32 kein ADS unterstützt. Entsprechendes wird also auch beim Kopieren auf ReFS gelten.

Aus diesen Gründen sollte man wirklich wichtige, unbedingt erforderliche Informationen nicht in ADS speichern, sondern nur entbehrliche oder rekonstruierbare Zusatzinformationen.

Siehe auch  Alternativer Datenstrom.

herbivore

PS: Unter OS/2 wurden ADS häufiger genutzt. Zum Beispiel hat mein favorisierter Editor die Cursorposition beim letzten Speichern in einem ADS abgelegt, so dass man beim erneuten Öffnen dort weiter machen konnte, wo man aufgehört hat. Sowas ist ein guter Anwendungsfall für ADS, denn wenn diese Information doch mal verloren geht, ist es auch nicht weiter tragisch.
17.10.2012 00:17 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
vitafit vitafit ist männlich
myCSharp.de-Mitglied

avatar-3270.png


Dabei seit: 15.05.2011
Beiträge: 23
Entwicklungsumgebung: Visual Studio 2012
Herkunft: Hessen


vitafit ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat von Borg:
Desweiteren kann weder der Explorer noch der dir-Befehl ADS anzeigen.
Daher kann ich auch mit einer für den Nutzer scheinbar 1Byte großen Datei die gesamte Festplatte füllen.
Also: acht geben, wofür man die ADS nutzt und dem Nutzer immer (spätestens bei der Deinstallation) die Möglichkeit gewähren, alle erzeugten ADS auch wieder zu entfernen.

Da muss ich dir wiedersprechen - dir /R offenbart dir sofort, ob ein Stream in der Datei versteckt ist - diese lassen sich auch ohne Probleme (eben im Selbsttest Windows 8 ausprobiert) öffnen :)


mycsharp.de  Moderationshinweis von herbivore (19.10.2012 07:46):

Die Option /r gibt es ab Windows Vista, welches am am 30. Januar 2007 veröffentlicht wurde. Die Aussage von Borg stammt vom 25.10.2006, war also zu diesem Zeitpunkt richtig und bleibt es auch für Windows Versionen vor Vista, also insbesondere für XP.
 
18.10.2012 19:49 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Baumstruktur | Brettstruktur       | Top 
myCSharp.de | Forum Der Startbeitrag ist älter als 12 Jahre.
Der letzte Beitrag ist älter als 6 Jahre.
Antwort erstellen


© Copyright 2003-2019 myCSharp.de-Team | Impressum | Datenschutz | Alle Rechte vorbehalten. | Dieses Portal verwendet zum korrekten Betrieb Cookies. 15.09.2019 20:26