La memoria que maneja el sistema operativo tiene limitaciones importantes, dos de ellas son la escasa cantidad de información que se puede almacenar en un espacio de direcciones, la otra es la volatilidad de los datos. La solución a este problema es almacenar la información en dispositivos de almacenamiento no volátil como son los discos duros, discos ópticos, etc.
El almacenamiento de la información se lleva a cabo mediante archivos (también llamados ficheros). Un archivo se define como conjunto de datos almacenados en un dispositivo de almacenamiento, un ejemplo es una imagen fotográfica que consiste en un conjunto de bits con un formato.
En general, los sistemas operativos distinguen entre estos tipos de archivos:
- Normales: los archivos pueden contener cualquier tipo de información, en algunos casos pueden ser programas que una vez ejecutados pasan a ser procesos. Dentro de los archivos normales podemos encontrar archivos ejecutables, de audio, de imágenes, de vídeo, comprimidos, etc.
- Directorios: son archivos que contienen información sobre la organización y estructura de otros archivos.
- Especiales: estos archivos permiten comunicarse con dispositivos de E/S (archivos especiales de caracteres) o con discos (archivos especiales de bloques).
Es más sencillo utilizar archivos que tratar con el disco duro directamente. El sistema operativo gestiona los archivos mediante el sistema de archivos.
El sistema de archivos se puede definir como un conjunto de normas y procedimientos para almacenar información en los dispositivos de almacenamiento.
Los sistemas de archivos permiten organizar los datos en los dispositivos de almacenamiento siguiendo una serie de normas y restricciones. Un sistema de archivos se implanta después de crear una partición en un dispositivo de almacenamiento (disco duro, USB, CD/DVD, etc.).
Algunas características de los sistemas de archivos son:
- Cada sistema operativo utiliza su propio sistema de archivos.
- Un sistema operativo con un sistema de archivos no tiene por qué leer otro sistema de archivos de otro sistema operativo distinto.
El sistema de archivos que se utiliza actualmente en Windows es NTFS (New Technology File System, Sistema de archivos de nueva tecnología) es el sistema de archivos que utiliza Windows 2000, xP, Vista, 7, Server 2003 y Server 2008. Es un sistema de archivos que se desarrolló para la versión NT de Windows, admite 255 caracteres y los nombres pueden estar codificados en Unicode.
Los archivos tiene propiedades, algunas propiedades que tienen los archivos:
- Nombre: sirve para identificar un archivo, la mayoría de los sistemas operativos permiten utilizar nombres de hasta 255 caracteres, algunos sistemas operativos hacen distinciones entre minúsculas y mayúsculas, por ejemplo, un fichero con el nombre Trabajo y otro con el nombre trabajo son considerados en Windows como el mismo archivo. En el caso de haber dos ficheros o más con el mismo nombre en el mismo sistema de archivos, éstos deben estar en ubicaciones distintas.
- Extensión: la extensión sirve para saber el tipo de programa que lo ejecuta o interpreta, algunos sistemas operativos como Windows utilizan extensiones.
- Tipo de archivo: pueden dividirse en normales, directorios o especiales.
- Ubicación: lugar del sistema de archivos donde se encuentra un archivo.
- Tamaño: cantidad de bytes que ocupa un fichero en el sistema de archivos.
- Fecha de creación, modificación y último acceso: para cada archivo indica la fecha en que ha sido creado, modificado y la última vez que se accedió a él.
- Atributos: son propiedades que permiten asignar características especiales a los archivos, algunos ejemplos son atributos de sólo lectura, de archivo, de sistema, ocultar, cifrar, comprimir, etc.
- Permisos: se utilizan para permitir o restringir el acceso a los archivos a determinados usuarios o grupos. Los permisos pueden ser para: leer, modificar, eliminar, renombrar, etc.
Ejemplos
Mostrar información sobre archivos
1 | Get-ChildItem -Path $home |
Mostrar archivos ocultos
1 | Get-ChildItem -Path $home –Hidden |
Discos
Los dispositivos de almacenamiento tienen una estructura física y una estructura lógica. La estructura física de los discos viene de fábrica y son los platos, las caras, las pistas y los sectores. La estructura lógica consiste en implantar sobre la estructura física un sistema de archivos mediante el formato.
Cmdlet que muestra información sobre discos físicos
1 | Get-Disk |
Dar formato es crear un sistema de archivos en un dispositivo de almacenamiento, así se prepara al dispositivo para guardar información.
Antes de dar formato a un disco, éste se puede dividir en partes y cada una de ellas albergará particiones, este proceso de división del disco de denomina particionado.
Las particiones pueden ser:
- Partición primaria: desde donde se inicia el sistema operativo, contiene el sector de arranque.
- Partición extendida: se comporta como una unidad primaria y se utiliza para almacenar información. Dentro de este tipo de unidad se pueden añadir particiones lógicas que ocupan una parte o el total de dicha partición.
La forma de nombrar los dispositivos de almacenamiento depende del sistema operativo, en el caso de Windows, la disquetera, el CD, el DVD, los USB y las particiones del disco duro reciben un nombre que consiste en una letra del alfabeto seguida de dos puntos.
Ejemplo
Ver el tipo de tabla de particiones
1 | (Get-Disk).PartitionStyle |
Discos físicos
Información sobre discos físicos
Cmdlet
1 | Get-Disk |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | UniqueId {Id} FriendlyName {} SerialNumber {} Path {} Number {DeviceId} Partition {} VirtualDisk {} iSCSISession {} iSCSIConnection {} StorageSubSystem {} StorageNode {} StorageJob {} CimSession {Session} ThrottleLimit {} AsJob {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} |
Ejemplo
Mostrar información sobre los discos
1 | Get-Disk |
Crear una partición
Cmdlet
1 | New-Partition |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | DiskId {Id} DiskPath {} DiskNumber {} InputObject {} Size {} UseMaximumSize {} Offset {} Alignment {} DriveLetter {NewDriveLetter} AssignDriveLetter {} MbrType {} GptType {} IsHidden {} IsActive {} CimSession {Session} ThrottleLimit {} AsJob {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} |
Ejemplo
Crear una partición
1 | New-Partition -DiskNumber 1 -UseMaximumSize -AssignDriveLetter |
Dar formato
Cmdlet
1 | Format-Volume |
Alias
1 | Initialize-Volume |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | ObjectId {Id} Path {} FileSystemLabel {} DriveLetter {} Partition {} InputObject {} FileSystem {} NewFileSystemLabel {} AllocationUnitSize {ClusterSize} Full {} Force {} Compress {} ShortFileNameSupport {} SetIntegrityStreams {} UseLargeFRS {} DisableHeatGathering {} IsDAX {} CimSession {Session} ThrottleLimit {} AsJob {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} |
Ejemplo
Dar formato a la unidad f
1 | Format-Volume -DriveLetter f |
Discos virtuales
Crear discos virtual
Cmdlet
1 | New-VHD |
Ejemplo
Crear un disco virtual de 1GB
1 | New-VHD –Path f:\disc.vhdx –SizeBytes 1GB |
Montar un disco virtual
Cmdlet
1 | Mount-VHD |
Ejemplo
Montar un disco virtual que se ha creado anteriormente
1 | Mount-VHD –Path f:\disco.vhdx |
Particiones
Listar particiones del sistema
Cmdlet
1 | Get-Partition |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | UniqueId {} DiskId {DiskPath} Offset {} DiskNumber {} PartitionNumber {Number} DriveLetter {} Disk {} Volume {} StorageSubSystem {} CimSession {Session} ThrottleLimit {} AsJob {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} |
Obtener información lógica sobre particiones
Llamada WMI (información lógica sobre los discos como el ID, espacio vacío, tamaño de partición)
1 | Get-WmiObject win32_logicalDisk |
Ejemplo
Listar el nombre de las unidades de las particiones
1 2 | Get-Partition | Select-Object DriveLetter (Get-Partition).DriveLetter |
Ejercicios
Comprobar espacio en unidades
1 2 3 | get-wmiobject win32_volume -computername . | select name, @{expression={$_.capacity/1GB}}, @{expression={$_.freespace/1GB}}, @{name=”% Free”;expression={$_.freespace/ $_.capacity*100}} |
Detectar la partición sobre la que se ha instalado el sistema operativo
1 | Get-WmiObject Win32_AutochkSetting |
El sistema operativo se instala sobre una partición teniendo en cuenta el espacio del disco porque luego crece el sistema operativo.
Cifrado
Los discos se pueden cifrar en Windows con BitLocker.
Habilitar BitLocker en un disco
Cmdlet
1 | Enable-BitLocker |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | MountPoint {} EncryptionMethod {} HardwareEncryption {} SkipHardwareTest {s} UsedSpaceOnly {qe} PasswordProtector {pwp} Password {pw} RecoveryPasswordProtector {rpp} RecoveryPassword {rp} StartupKeyProtector {skp} StartupKeyPath {sk} AdAccountOrGroupProtector {sidp} Service {} AdAccountOrGroup {sid} TpmAndPinAndStartupKeyProtector {tpskp} Pin {p} TpmAndPinProtector {tpp} TpmAndStartupKeyProtector {tskp} TpmProtector {tpmp} RecoveryKeyProtector {rkp} RecoveryKeyPath {rk} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} |
Ejemplo
Habilitar BitLocker en el disco f
1 | Enable-BitLocker -MountPoint "f:" -RecoveryPasswordProtector -UsedSpaceOnly -Verbose |
Deshabilitar BitLocker en un disco
Cmdlet
1 | Disable-BitLocker |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | MountPoint {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} |
Ejemplo
Deshabilitar BitLocker en el disco f
1 | Disable-BitLocker -MountPoint "f:" |
La ruta
Hay varias formas de nombrar a los sistemas por la organización de los directorios:
- Sistemas de directorios de un solo nivel: sólo hay un directorio y contiene todos los archivos.
- Sistemas de directorios jerárquicos: un directorio puede incluir otros directorios y archivos.
Dentro de una estructura de directorios, el directorio actual es en el que está un usuario por defecto (el carácter “.” representa el directorio actual) o en el que se encuentra en un momento determinado. Si queremos saber el directorio donde nos encontramos en Linux, se utiliza el comando pwd, y si utilizamos PowerShell en Windows, ejecutamos el comando Get-Location o pwd.
Para obtener la ubicación de trabajo actual se utiliza el cmdlet
1 | Get-Location |
Alias
1 2 | gl pwd |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | PSProvider {} PSDrive {} Stack {} StackName {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} UseTransaction {usetx} |
El directorio padre es el que está por encima del directorio en el que se encuentra un usuario (el carácter “..” representa el directorio padre).
Para llamar a un archivo dentro de una estructura de directorios se utiliza el concepto de ruta. Se define como una concatenación de directorios y subdirectorios desde el directorio raíz (es donde empieza la estructura de directorios) hasta el directorio donde está el archivo.
Hay dos tipos de rutas: ruta absoluta y ruta relativa. La ruta absoluta es la forma de llamar a un archivo desde el directorio raíz hasta el archivo, un ejemplo de ruta absoluta en Windows es C:\Users\Juan\ejemplo.txt, dependiendo del sistema de archivos podemos tener el carácter “\” o “/”.
Otra forma de llamar a un archivo es mediante una ruta relativa que consiste en nombrar al archivo respecto al directorio actual, un ejemplo de ruta relativa en Windows es ..\User\Juan\ejemplo.txt.
Ejercicio
Encontrar y localizar la ruta de un fichero
1 | Get-ChildItem -Recurse | % {if($_.Name | Select-String "fichero"){$_.FullName}} |
Permisos
Los permisos se utilizan para permitir o restringir el acceso a los archivos a determinados usuarios o grupos. Los permisos pueden ser para: leer, modificar, eliminar, renombrar, etc.
En los sistemas de archivos suele compartirse información con otros usuarios, esto hace necesario controlar el acceso a los archivos. Un permiso indica qué cosas puede hacer un usuario o grupo de usuarios en cualquier archivo, por ejemplo, uno de texto.
Los permisos se pueden agregar o denegar a un usuario o grupo se usuarios. En este apartado se muestran los seis permisos estándar para el sistema de ficheros NTFS:
- Control total. Cuando se aplica este tipo de permiso a un archivo, éstos se pueden leer, escribir, cambiar y eliminar; también se pueden cambiar permisos en los archivos. En el caso concreto del tipo de archivo carpeta, significa que se permite leer, escribir, cambiar y eliminar.
- Modificar. En el caso de los archivos se pueden leer, escribir, cambiar y eliminar, con este permiso no se pueden modificar los permisos. En el caso concreto de las carpetas, se puede leer, escribir, cambiar y eliminar ficheros y subcarpetas.
- Lectura y ejecución. Se puede acceder a los ficheros y ejecutarlos. En el caso de las carpetas, se puede ver el contenido de una carpeta y ejecutar.
- Lectura. Se puede ver el contenido de los archivos pero no se pueden ejecutar. En el caso de las carpetas se puede acceder al contenido.
- Escritura. Cuando se aplica a los archivos quiere decir que se pueden modificar pero no eliminar. En el caso de las carpetas se pueden añadir ficheros y subcarpetas.
- Mostrar el contenido. En el caso de los archivos de tipo carpeta se puede mostrar el contenido que hay en ellos. Además de estos permisos estándar, también existen los permisos especiales.
Los permisos pueden ser: permisos explícitos y permisos heredados.
Los permisos explícitos son aquellos que se establecen de forma predeterminada en archivos que no son secundarios cuando son creados por el usuario.
Los permisos heredados son los que se propagan a un archivo desde un archivo primario.
De forma predeterminada, los objetos de un contenedor heredan los permisos desde ese contenedor cuando se crean los objetos. Por ejemplo, cuando se crea la carpeta ejemplo, todas las subcarpetas y archivos creados en la carpeta ejemplo heredan de forma automática los permisos de la misma. De esta manera, la carpeta ejemplo tiene permisos explícitos, mientras que las subcarpetas y los archivos heredan los permisos.
Ejemplo
Obtener los descriptores de seguridad de todos los ficheros de una unidad
1 | Get-ChildItem D:\ -Recurse | %{Get-Acl $_.FullName | Select-Object Sddl} |
Archivos
El almacenamiento de la información se lleva a cabo mediante archivos (también llamados ficheros). Un archivo se define como conjunto de datos almacenados en un dispositivo de almacenamiento, un ejemplo es una imagen fotográfica que consiste en un conjunto de bits con un formato.
Las operaciones que se pueden realizar con cmdlets son:
Obtener archivos
Nombre del cmdlet
1 | Get-ChildItem |
Alias
1 2 3 | gci ls dir |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | Path {} LiteralPath {PSPath} Filter {} Include {} Exclude {} Recurse {s} Depth {} Force {} Name {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} UseTransaction {usetx} Attributes {} Directory {ad, d} File {af} Hidden {ah, h} ReadOnly {ar} System {as} |
Ejemplo
Fecha de creación de archivos
1 | Get-ChildItem C:\Users | Select-Object CreationTime,name |
Mostrar archivos ocultos de forma recursiva
1 | Get-ChildItem -Path $home –Hidden -Recurse |
Ejercicios
Listar archivos abiertos recientemente
1 | Get-ChildItem ([Environment]::GetFolderPath("Recent")) |
Listar Cookies
1 | Get-ChildItem ([Environment]::GetFolderPath("Cookies")) |
Obtener un listado de todos los ficheros EXE que hay en el sistema
1 | Get-ChildItem c:\ "*.exe" -recurse | Select-Object FullName,Name |
Crear archivos
Nombre del cmdlet
1 2 | New-Item New-Item -ItemType File |
Alias
1 | ni |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | Path {} Name {} ItemType {Type} Value {Target} Force {} Credential {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} UseTransaction {usetx} |
El parámetro –Path ruta indica la ubicación del archivo dentro de la estructura del sistema de archivos. El parámetro –Name nombre especifica el nombre del archivo. El parámetro –ItemType file indica que es un archivo (“file”) y no un directorio ni cualquier otro elemento. El parámetro –Value “datos” incorpora contenido al fichero.
Otros parámetros que se pueden añadir al cmdlet son:
- Credential. Especifica una cuenta de usuario que tenga permiso para realizar una acción, por defecto el valor es el usuario actual. Este parámetro tiene sentido cuando se intenta crear un archivo en un equipo de la red.
- Force. Permite al cmdlet crear un elemento que escribe sobre un elemento existente de solo lectura, en ningún caso se pasan por alto las restricciones de seguridad.
- Confirm. Pide confirmación antes de ejecutar el cmdlet.
- WhatIf. muestra un mensaje en el que se describe la ejecución del cmdlet.
Ejemplo
Crear un archivo
1 | New-Item c:\fichero.txt -ItemType file |
Enviar la salida de un comando a un fichero
Nombre del cmdlet
1 | Out-File |
Alias
1 | Ninguno (aunque se puede utilizar el carácter > para crear y sobreescribir un fichero y >> para añadir contenido a un archivo) |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | FilePath {} LiteralPath {PSPath} Encoding {} Append {} Force {} NoClobber {NoOverwrite} Width {} NoNewline {} InputObject {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} |
Ejemplo
Almacenar contenido en un fichero
1 | Get-Process | Out-File c:\scripts\procesos.txt |
Almacenar contenido en un fichero
Nombre del cmdlet
1 | Set-Content |
Alias
1 | sc |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | Value {} PassThru {} Path {} LiteralPath {PSPath} Filter {} Include {} Exclude {} Force {} Credential {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} UseTransaction {usetx} NoNewline {} Encoding {} Stream {} |
Ejemplo
Almacenar contenido en un fichero
1 | Set-Content c:\scripts\fichero.txt "Añadir contenido a un archivo" |
Agregar contenido a un fichero
Agrega contenido a un fichero pero no borra el contenido que ya tenía.
Nombre del cmdlet
1 | Add-Content |
Alias
1 | ac |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | Value {} PassThru {} Path {} LiteralPath {PSPath} Filter {} Include {} Exclude {} Force {} Credential {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} UseTransaction {usetx} NoNewline {} Encoding {} Stream {} |
Ejemplo
Agregar la palabra FIN a todos los ficheros txt
1 | Add-Content -Path *.txt -Value "FIN" |
Vaciar el contenido de un fichero
Nombre del cmdlet
1 | Clear-Content |
Alias
1 | clc |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | Path {} LiteralPath {PSPath} Filter {} Include {} Exclude {} Force {} Credential {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} UseTransaction {usetx} Stream {} |
Ejemplo
Vaciar el contenido de un fichero
1 | Clear-Content c:\scripts\test.txt |
Vaciar el contenido de un item
Nombre del cmdlet
1 | Clear-Item |
Alias
1 | cli |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | Path {} LiteralPath {PSPath} Force {} Filter {} Include {} Exclude {} Credential {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} UseTransaction {usetx} |
Ejemplo
Vaciar el contenido de un fichero
1 | Clear-Item fichero.txt |
Ver el contenido de un fichero
Nombre del cmdlet
1 | Get-Content |
Alias
1 | gc |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | ReadCount {} TotalCount {First, Head} Tail {Last} Path {} LiteralPath {PSPath} Filter {} Include {} Exclude {} Force {} Credential {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} UseTransaction {usetx} Delimiter {} Wait {} Raw {} Encoding {} Stream {} |
Ejemplos
Ver el contenido de un fichero
1 | Get-Content fichero.txt |
Ver la última línea de un fichero
1 | Get-Content .\fichero.txt -Tail 1 |
Importar el contenido de un fichero separado por comas
Nombre del cmdlet
1 | Import-Csv |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | Delimiter {} Path {} LiteralPath {PSPath} UseCulture {} Header {} Encoding {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} |
Ejemplo
Importar un fichero y almacenarlo en una variable
1 | $var=Import-Csv fichero.txt |
Importar el contenido de un fichero XML
Nombre del cmdlet
1 | Import-Clixml |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | Path {} LiteralPath {PSPath} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} IncludeTotalCount {} Skip {} First {} |
Ejemplo
Importar un fichero XML y almacenarlo en una variable
1 | $var=Import-Clixml fichero.xml |
Exportar contenido a un fichero separando por comas
Nombre del cmdlet
1 | Export-Csv |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | InputObject {} Path {} LiteralPath {PSPath} Force {} NoClobber {NoOverwrite} Encoding {} Append {} Delimiter {} UseCulture {} NoTypeInformation {NTI} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} |
Ejemplo
Exportar la información sobre los procesos que se están ejecutando y almacenarla en un fichero separado por comas
1 | Get-Process | Export-Csv fichero.txt |
Ejercicio
Crear un array y exportar el contenido a un fichero separado por comas
1 2 3 4 5 6 7 8 9 10 11 12 | $csv = @' Libro,Cantidad SOM,15 ISO,16 '@ $data = $csv | ConvertFrom-Csv $data.Libro $data.Cantidad $data | Out-GridView |
Exportar contenido a un fichero XML
Nombre del cmdlet
1 | Export-Clixml |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | Depth {} Path {} LiteralPath {PSPath} InputObject {} Force {} NoClobber {NoOverwrite} Encoding {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} |
Ejemplo
Exportar la información sobre los procesos que se están ejecutando y almacenarla en un fichero XML
1 | Get-Process | Export-Clixml fichero.xml |
Copiar ficheros
Nombre del cmdlet
1 | Copy-Item |
Alias
1 2 3 | cpi cp copy |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | Path {} LiteralPath {PSPath} Destination {} Container {} Force {} Filter {} Include {} Exclude {} Recurse {} PassThru {} Credential {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} UseTransaction {usetx} FromSession {} ToSession {} |
Ejemplo
Copiar un fichero
1 | Copy-Item fichero.txt fichero2.txt |
Eliminar un fichero
Nombre del cmdlet
1 | Remove-Item |
Alias
1 2 3 4 5 6 | ri rm rmdir del erase rd |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | Path {} LiteralPath {PSPath} Filter {} Include {} Exclude {} Recurse {} Force {} Credential {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} UseTransaction {usetx} Stream {} |
Ejemplos
Eliminar un fichero
1 | Remove-Item fichero.txt |
Eliminar varios ficheros de forma recursiva
1 | Remove-Item c:\ficheros\* -recurse |
Mover un fichero
Nombre del cmdlet
1 | Move-Item |
Alias
1 2 3 | mi mv move |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | Path {} LiteralPath {PSPath} Destination {} Force {} Filter {} Include {} Exclude {} PassThru {} Credential {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} UseTransaction {usetx} |
Ejemplo
Mover un fichero a otra ubicación (a la carpeta llamada nueva)
1 | Move-Item fichero.txt .\nueva\ |
Renombrar
Nombre del cmdlet
1 | Rename-Item |
Alias
1 2 | rni ren |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | Path {} LiteralPath {PSPath} NewName {} Force {} PassThru {} Credential {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} UseTransaction {usetx} |
Ejemplo
Cambiar el nombre a un fichero
1 | Rename-Item .\fichero.txt .\fichero2.txt |
Renombrar varios ficheros de texto
1 2 3 4 | Get-ChildItem *.txt | %{ #Simular con WhatIf antes de renombrar Rename-Item -Path $_ -NewName "$($_.basename).bak" -WhatIf } |
Imprimir
Nombre del cmdlet
1 | Out-Printer |
Alias
1 | lp |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 | Name {PrinterName} InputObject {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} |
Ejemplo
Imprimir un fichero en la impresora PDF
1 2 | $contenido=Get-Content fichero.txt Out-Printer -InputObject $contenido -name "PDF24 PDF" |
Comprimir
Nombre del cmdlet
1 | Compress-Archive |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | Path {} LiteralPath {PSPath} DestinationPath {} CompressionLevel {} Update {} Force {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} |
Ejemplo
1 | Compress-Archive -LiteralPath C:\powershell\example.txt –CompressionLevel Optimal -DestinationPath C:\powershell\comprimido.zip |
Añadir un archivo un fichero comprimido
Nombre del cmdlet
1 | Compress-Archive |
Ejemplo
1 | Compress-Archive -LiteralPath C:\powershell\example2.txt -Update -DestinationPath C:\powershell\comprimido.zip |
Descomprimir
Nombre del cmdlet
1 | Expand-Archive |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | Path {} LiteralPath {PSPath} DestinationPath {} Force {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} |
Ejemplo
1 | Expand-Archive -LiteralPath C:\powershell\comprimido.zip -DestinationPath C:\powershell\descomprimir |
Permisos
En PowerShell hay un cmdlet que obtiene las listas de control de acceso (ACL) de un archivo. La lista ACL indica los permisos que tienen los usuarios y los grupos de usuarios para obtener acceso al recurso. Una vez que obtenemos la lista de control podemos asignarla a otros archivos.
Nombre del cmdlet que sirve para ver permisos
1 | Get-Acl –Path archivo |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | Path {} InputObject {} LiteralPath {PSPath} Audit {} AllCentralAccessPolicies {} Filter {} Include {} Exclude {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} UseTransaction {usetx} |
En el parámetro –Path archivo hay que incluir la ruta del archivo y el nombre del archivo del que vamos a obtener los permisos.
Nombre del cmdlet que sirve para establecer permisos
1 | Set-Acl –Path archivo |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | Path {} InputObject {} LiteralPath {PSPath} AclObject {} CentralAccessPolicy {} ClearCentralAccessPolicy {} Passthru {} Filter {} Include {} Exclude {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} UseTransaction {usetx} |
En el parámetro –Path archivo hay que incluir la ruta del archivo y el nombre del archivo en el que vamos asignar los permisos.
Ejemplos
Ver permisos
1 | Get-Acl d: | Select-Object Access |
Clonar permisos
1 2 | Get-Acl Set-Acl |
Crear ACL
1 | New-Object -TypeName System.Security.AccessControl.FileSystemAccessRule |
Realizar función hash sobre un archivo
Las funciones hash sirven para calcular un valor valor único que corresponde al contenido del archivo, el valor hash para un archivo depende del algoritmo utilizado.
El valor hash sobre el fichero cambia en el momento en el que se cambia el contenido del archivo.
El cmdlet que sirve para realizar funciones hash es
1 | Get-FileHash |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | LiteralPath {PSPath} InputStream {} Algorithm {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} |
Los algoritmos que se pueden utilizar para realizar la función hash son:
- SHA1
- SHA256
- SHA384
- SHA512
- MACTripleDES
- MD5
- RIPEMD160
Ejemplo
Realizar la función hash SHA512 sobre un fichero
1 | Get-FileHash .\fichero1.txt -Algorithm SHA512 |
Directorios
Las operaciones que se pueden realizar con cmdlets son:
Crear un una carpeta
Nombre del cmdlet
1 | New-Item -ItemType Directory |
Alias
1 | ni |
Ejemplo
Crear un directorio
1 | New-Item c:\powerShell -type directory |
Cambiar de directorio
Nombre del cmdlet
1 | Set-Location |
Alias
1 2 3 | cd chdir sl |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | Path {} LiteralPath {PSPath} PassThru {} StackName {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} UseTransaction {usetx} |
Ejemplo
Acceder a la carpeta scripts dentro de la unidad d
1 | Set-Location D:\scripts |
Listar el contenido de un directorio
Nombre del cmdlet
1 | Get-ChildItem |
Alias
1 2 3 | ls dir gci |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | Path {} LiteralPath {PSPath} Filter {} Include {} Exclude {} Recurse {s} Depth {} Force {} Name {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} UseTransaction {usetx} Attributes {} Directory {ad, d} File {af} Hidden {ah, h} ReadOnly {ar} System {as} |
Ejemplo
Ver el contenido de la carpeta scripts
1 | Get-ChildItem D:\scripts |
Copiar carpetas
Nombre del cmdlet
1 | Copy-Item |
Alias
1 2 3 | cpi cp copy |
Ejemplo
Copiar una carpeta
1 | Copy-Item .\carpeta .\carpeta1 |
Borrar carpetas
Nombre del cmdlet
1 | Remove-Item |
Ejemplo
Eliminar la carpeta scripts1
1 | Remove-Item c:\scripts1 |
Mover carpetas
Nombre del cmdlet
1 | Move-Item |
Ejemplo
Mover una carpeta
1 | Move-Item .\carpeta .\carpeta1 |
Renombrar carpetas
Nombre del cmdlet
1 | Rename-Item |
Ejemplo
Cambiar el nombre a una carpeta
1 | Rename-Item .\carpeta1 .\carpeta2 |
Comprimir
Nombre del cmdlet
1 | Compress-Archive |
Ejemplo
1 | Compress-Archive -LiteralPath C:\powershell\carpeta\ –CompressionLevel Optimal -DestinationPath C:\powershell\comprimido.zip |
Añadir un archivo al directorio comprimido
Nombre del cmdlet
1 | Compress-Archive |
Ejemplo
1 | Compress-Archive -LiteralPath C:\powershell\carpeta\example2.txt -Update -DestinationPath C:\powershell\comprimido.zip |
Descomprimir
Nombre del cmdlet
1 | Expand-Archive |
Ejemplo
1 | Expand-Archive -LiteralPath C:\powershell\comprimido.zip -DestinationPath C:\powershell\descomprimir\ |
Permisos
Nombre del cmdlet que sirve para ver permisos
1 | Get-Acl –Path directorio |
En el parámetro –Path directorio hay que incluir la ruta del directorio del que vamos a obtener los permisos.
Nombre del cmdlet que sirve para establecer permisos
1 | Set-Acl –Path archivo |
En el parámetro –Path directorio hay que incluir la ruta del directorio en el que vamos asignar los permisos.
Ejemplos
Ver permisos
1 | Get-Acl .\carpeta | Select-Object Access |
Clonar permisos
1 2 | Get-Acl Set-Acl |
Crear ACL
1 | New-Object -TypeName System.Security.AccessControl.FileSystemAccessRule |
Ejercicio
Eliminar permisos explícitos en un directorio
1 2 3 4 5 6 7 8 9 10 11 12 13 | #Los permisos explícitos son aquellos que se establecen de forma predeterminada en objetos que no son secundarios cuando se crea el objeto, o los que crea el usuario en objetos secundarios, primarios o que no son secundarios. $Path = ‘F:\power\permisos’ $acl = Get-Acl -Path $path $acl.Access | Select-Object IdentityReference,IsInherited #Eliminar permisos explícitos #RemoveAccessRule quita todos permisos de la lista de control de acceso (ACL) Allow o Deny coincidentes del archivo o directorio actual. $acl.Access | Where-Object{!($_.isInherited)} | ForEach-Object {$acl.RemoveAccessRule($_)} $acl.Access | Select-Object IdentityReference,IsInherited #Asignar nuevos permisos $acl | Set-Acl -Path $path |
Compartir una carpeta
Nombre del cmdlet
1 | New-SmbShare |
Alias
1 | nsmbs |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | Temporary {} ContinuouslyAvailable {} Description {} ConcurrentUserLimit {} CATimeout {} FolderEnumerationMode {} CachingMode {} FullAccess {} ChangeAccess {} ReadAccess {} NoAccess {} SecurityDescriptor {} Path {} Name {} ScopeName {} EncryptData {} CimSession {Session} ThrottleLimit {} AsJob {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} WhatIf {wi} Confirm {cf} |
Ejemplo
Crear carpeta compartida y asignar permisos
1 | New-SmbShare -Name fso -Path F:\power –FullAccess administrador -ReadAccess Everyone |
Ver carpetas compartidas
Nombre del cmdlet
1 | Get-SmbShare |
Alias
1 | gsmbs |
Parámetros y alias de los parámetros
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | Name {} ScopeName {} Scoped {} Special {} ContinuouslyAvailable {} ShareState {} FolderEnumerationMode {} CachingMode {} ConcurrentUserLimit {} AvailabilityType {} CaTimeout {} EncryptData {} IncludeHidden {} SmbInstance {} CimSession {Session} ThrottleLimit {} AsJob {} Verbose {vb} Debug {db} ErrorAction {ea} WarningAction {wa} InformationAction {infa} ErrorVariable {ev} WarningVariable {wv} InformationVariable {iv} OutVariable {ov} OutBuffer {ob} PipelineVariable {pv} |
Cmdlet con llamada WMI que muestran información sobre las carpetas compartidas
1 | Get-WmiObject -Class Win32_Share |
Ejemplo
Ver carpetas compartidas
1 | Get-SmbShare |
Ver recursos compartidos
Nombre del cmdlet
1 | Get-WmiObject Win32_NetworkConnection |