No encontrar las librerías .h en linux

Las librerías que usa gcc y g++ (y creo que clang) están en /usr/include/ ...a veces el comando locate no encuentra las librerías.

ELF Basics Internal: Elf Basics.

/*Este material no lo hice yo. Source: oxhat.blogspot.com*/ In this post I will share details on ELF binary basics.

So let is begin with a very simple hello world program in C

#include stdio.h

int main(){printf("\nHello World\n");return 0;}

As I am on a 64 bit Linux system I will compile the binary for both 32bit and 64bit mode.

We will compile this code with gcc by issuing the command

for 64 bit -> gcc hello.c -o hello64
for 32 bit -> gcc hello.c -m32 -o hello32

, ( in case we get error we can install gcc multilib by issuing command sudo apt-get install gcc-multilib ) If we issue file command on the binary we created we would see the following output

pentest@ubuntu:~/Desktop$ file hello64 hello64: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=797fa6ea8a92b773eb5106c822a76788441ceac1, not stripped
pentest@ubuntu:~/Desktop$ file hello32 hello32: ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=ba188ad09ee9ff9ac774833b8a7c87d8afbc443a, not stripped

So let us try to understand what all these mean (we will analyze the result of 64 bit binary)

hello64: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=797fa6ea8a92b773eb5106c822a76788441ceac1, not stripped

hello64: This is the filename of the binary on which we are executing the file command
ELF - Executable and Linking Format or Executable and Linkable Format - This mean that the binary type is associated with mainly UNIX type operating system , like Linux, Solaris but also supports certain non UNIX operating system.
64bit - This gives us information tells about the architecture of the binary that it is 64 bit. So if it is a 32 bit binary it will be shown as 32 If we are in a 64bit machine and if we want to create a 32 bit binary we can pass the -m32 option
LSB - Least Significant Byte - It means the binary is in little endian format. In Intel architecture you will often find this as LSB. However in architectures like PowerPC , SPARC and so on it is possible to get this in big endian format i.e MSB ( Most Significant Byte )
Shared object - This result can either be Shared Object or Relocatable or Executable.
Let us see how these are different from each other and how we can generate them using gcc. The two terms which we are going to use here are PIC ( Position Independent Code ) and PIE ( Position Independent Executable) .
When we are planning to create a library that can be called by many process, we need to make it a PIC so that they can be loaded in the memory at any virtual address and just because they are position independent it can be accessed with relative offsets without worrying about the clashes of fixed locations in memory. We can create a PIE when Shared Object - By default the gcc compiler compiles the source code with -fPIC which makes address of the sections in the program relative to each other.
Executable - This mean this is not a PIE application. This loads with absolute address and thus we can find no reference of .plt.got sections here as the program is loaded in memory with fixed address .We can disable PIE with -no-pie option in gcc and thus we will get a executable object file.
Relocatable - This means this is just an object code without any linking of libraries or files that are necessary for the execution.
There are some steps involved when we make a program that can be executable ( Please Note: The term executable here means here is to make it run or execute and should not be confused with the above executable object type ).
To make an executable from source program the following process is involved.

Preprocessing -> Compilation -> Object File Creation -> Linking.

Normally in gcc we do in one step like gcc hello.c -o hello.out
but however we can do in 2 steps like gcc -c hello.c ; this will create an object file called hello.o This is how the disassembly of main looks like in object code.

0000000000000000 <main>:
0: 55 push rbp
1: 48 89 e5 mov rbp,rsp
4: 48 8d 3d 00 00 00 00 lea rdi,[rip+0x0] # b <main+0xb>
b: e8 00 00 00 00 call 10 <main+0x10>
10: 90 nop
11: 5d pop rbp
12: c3 ret

This program cannot run or do anything because the object code doesn't have the necessary linked objects or libraries required for execution. We can generate an executable binary from object code using the command
gcc hello.o -o hello-executable Now if we run objdump on the binary we can see lots of sections getting created with the location to the linkers.
This is how the disassembly of main looks like after linking

000000000000063a <main>:
63a: 55 push rbp
63b: 48 89 e5 mov rbp,rsp
63e: 48 8d 3d 8f 00 00 00 lea rdi,[rip+0x8f] # 6d4
<_IO_stdin_used+0x4>
645: e8 c6 fe ff ff call 510
<puts@plt>
64a: 90 nop
64b: 5d pop rbp
64c: c3 ret
64d: 0f 1f 00 nop DWORD PTR [rax]

Nota: Lo marcado con fondo rojo va al final de la línea anterior.
version 1 (SYSV) - This means that it uses version 1 and the target operating system for the binary is SYSTEM V. There can be other possible values for this for example FreeBSD, HP-UX , etc,. I didn't get enough resource from where I can find more details on the version 1 result and how it can affect something.

Dynamically linked, interpreter /lib/ld-linux.so.2, - It means that the binary uses some dynamically linked libraries. There is 2 possible values possible for this.Dynamically linked and Statically Linked.

Dynamically Linked - It means the linker actually uses a reference to load dynamically linked libraries in memory during execution of the program from the location /lib/ld-linux.so.2
We can verify it by running the ldd on the binary

pentest@ubuntu:~/Desktop$ ldd hello64
linux-vdso.so.1 (0x00007fff96bc2000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f425eb2a000)
/lib64/ld-linux-x86-64.so.2 (0x00007f425f11d000)

Statically Linked - It means that the binary has been packed along with the libraries. So there is no dynamically linked libraries inside it. So if a binary is compiled with -shared option in gcc it will create a statically linked binary. So if we run ldd command on the binary it will tell that there is not a dynamic executable.

pentest@ubuntu:~/Desktop$ ldd helloStatic
not a dynamic executable

There is a huge difference in sizes of the binary when compiled with -shared option ( i.e statically )

-rwxrwxr-x 1 pentest pentest 8296 Feb 6 08:55 hello64
-rwxrwxr-x 1 pentest pentest 844704 Feb 7 09:28 helloStatic

At this point you might feel confused between the relocation of the binary that we discussed before and the linking which we are discussing now. Well when we talk about shared object or executable or relocatable object type, then we are actually dealing how the program will be loaded in memory but when we talk about linking, then it is all about how the external libraries will be linked to binaries - either dynamically via some shared resources or statically by packing it with the actual binary. So we can make this statement , an executable object type may have dynamic linked libraries. Than means even if we disable PIE we can still get an executable with dynamically linked libraries.

pentest@ubuntu:~/Desktop$ file helloNOPIE
helloNOPIE: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=2d986bca273f541af7a48ffb51f4d5fd22177c22, not stripped

pentest@ubuntu:~/Desktop$ ldd helloNOPIE
linux-vdso.so.1 (0x00007ffffe990000) libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fcb5e8c0000) /lib64/ld-linux-x86-64.so.2 (0x00007fcb5ecb1000)

for GNU/Linux 3.2.0 - The minimum kernel version required to execute the binary BuildID[sha1]=ba188ad09ee9ff9ac774833b8a7c87d8afbc443a - This ID is assigned to the binary during the build phase. Possibly during the linking phase as this is not visible in object code after compilation.
not stripped - This means that the certain but not all debugging information are available. It can also have a value stripped in case we remove the debug symbols. A stripped binary is smaller in size than an not stripped binary. When we strip a binary we remove some extra sections from a binary that is not relevant or required for execution but was added for making debugging easy. We can verify using gdb and we can keep debug symbols in a binary by compiling with -g option

pentest@ubuntu:~/Desktop$ gcc hello.c -g -o helloDebugSymbols pentest@ubuntu:~/Desktop$ gdb -q ./helloDebugSymbols
Reading symbols from ./helloDebugSymbols...done.
(gdb) info functions
All defined functions: File hello.c:
void main();
Non-debugging symbols:
0x00000000000004e8 _init
0x0000000000000510 puts@plt
0x0000000000000520 __cxa_finalize@plt
0x0000000000000530 _start
0x0000000000000560 deregister_tm_clones
0x00000000000005a0 register_tm_clones
0x00000000000005f0 __do_global_dtors_aux
0x0000000000000630 frame_dummy
0x0000000000000650 __libc_csu_init
0x00000000000006c0 __libc_csu_fini
0x00000000000006c4 _fini

Now we will try the same with Stripped Binary and we can see that as there there is no debug symbols there is no reference to the function void main() as per source code. However there are still certain debug information available. For example I can find the address of main function.

pentest@ubuntu:~/Desktop$ gcc hello.c -o helloNoDebugSymbols pentest@ubuntu:~/Desktop$ gdb -q ./helloNoDebugSymbols
Reading symbols from ./helloNoDebugSymbols...(no debugging symbols found)...done.
(gdb) info functions
All defined functions:
Non-debugging symbols:
0x00000000000004e8 _init
0x0000000000000510 puts@plt
0x0000000000000520 __cxa_finalize@plt
0x0000000000000530 _start
0x0000000000000560 deregister_tm_clones
0x00000000000005a0 register_tm_clones
0x00000000000005f0 __do_global_dtors_aux
0x0000000000000630 frame_dummy
0x000000000000063a main
0x0000000000000650 __libc_csu_init
0x00000000000006c0 __libc_csu_fini
0x00000000000006c4 _fini

We can strip it down further using strip function

pentest@ubuntu:~/Desktop$ strip -s helloNoDebugSymbols -o helloNoDebugSymbolsStripped
pentest@ubuntu:~/Desktop$ gdb -q ./helloNoDebugSymbolsStripped
Reading symbols from ./helloNoDebugSymbolsStripped...(no debugging symbols found)...done.
(gdb) info functions
All defined functions:
Non-debugging symbols:
0x0000000000000510 puts@plt
0x0000000000000520 __cxa_finalize@plt

So that's all for this blog post. In my further posts I will talk in more details about each of the part of elf binary in more details

Cambiar Zona Horaria

Intro
Respaldar
/etc/localtime
/usr/share/zoneinfo

Introduccion

Lo ideal seria usar systemdatectl o date pero en caso de que no puedas como en kali o simplemente no quieras se puede hacer manualmente

Respaldo Primero hay que ir como root a /etc/localtime/ y usar

cp localtime ~localtime

para crear un archivo ~localtime en caso de que falle.

/etc/localtime/ La zona horaria que usa nuestro linux se encuentra en /etc/localtime/ (en etc esta toda configuracion)

/usr/share/zoneinfo Nuestra Zona Horaria se encuentra en /usr/share/zoneinfo ,debemos ir a ella por consola como root y luego copiarla en vez de /etc/localtime (nuestra zona horaria), basta con usar:

cd /usr/share/zoneinfo ;cp zonahoraria localtime /etc/localtime

luego de esto aplicar reboot

sudo reboot

Nuestra hora puede ser colocada dentro del $PS1.
Espero les haya servido ¡Hasta la proxima!.

No se puede usar apt-get update

 /* Si les sale un mensaje como el siguiente en linux*/

W: Failed to fetch https://http.kali.org/kali/dists/kali-rolling/InRelease  Temporary failure resolving 'http.kali.org'

Hay que modificar /etc/resolv.conf y poner nameserver 8.8.8.8 agregandolo al final del archivo

Búsqueda y Manejo de Archivos

algunas caracteristicas mas incluyen la agilizacion de tareas: ls a* busca todos los archivos que empiecen con a y * significa que incluira cualquier cosa que venga despues. alinux aconux axenax.ls no puede leer los archivos que empiecen con . a m3nos que se use la opcion -a. ls -la

total 43

drwx------. 2 root root 3452 Apr 10 02:50 .
drwx------. 6 root root 3452 Apr  6 04:54 ..
-rw-------. 1 root root    7 Apr 10 02:50 .acl
-rw-------. 1 root root    6 Apr 10 02:47 aconux
-rw-------. 1 root root    5 Apr 10 02:46 alinux
-rw-------. 1 root root    7 Apr 10 02:47 axenax

sin -a

ls -l

total 32
-rw-------. 1 root root    6 Apr 10 02:47 aconux
-rw-------. 1 root root    5 Apr 10 02:46 alinux
-rw-------. 1 root root    7 Apr 10 02:47 axenax

ls /etc/*conf ver los archivos que terminan con conf
/etc/GeoIP.conf            /etc/nftables.conf
/etc/adduser.conf          /etc/nikto.conf
/etc/ca-certificates.conf  /etc/nsswitch.conf
/etc/debconf.conf          /etc/ntp.conf
/etc/deluser.conf          /etc/pam.conf
/etc/dns2tcpd.conf         /etc/proxychains4.conf
/etc/dnsmasq.conf          /etc/redsocks.conf
/etc/e2scrub.conf          /etc/request-key.conf
/etc/fuse.conf             /etc/resolv.conf
/etc/gai.conf              /etc/rsyslog.conf
/etc/host.conf             /etc/sensors3.conf
/etc/idmapd.conf           /etc/sestatus.conf
/etc/inxi.conf             /etc/smi.conf
/etc/ipsec.conf            /etc/strongswan.conf
/etc/ld.so.conf            /etc/sudo.conf
/etc/libao.conf            /etc/sudo_logsrvd.conf
/etc/libaudit.conf         /etc/sysctl.conf
/etc/logrotate.conf        /etc/ucf.conf
/etc/miredo.conf           /etc/updatedb.conf
/etc/mke2fs.conf           /etc/usb_modeswitch.conf
/etc/nfs.conf              /etc/xattr.conf
/etc/dconf:db           /etc/resolvconf:update.d

ademas de * puede ser usado ? pero este ultimo funciona solo con un caracter. son llamados comodines

ls l[abdcio]st.sh busca un archivo que empiece con l,seguido de a,b,d,c,i,o y luego st.
ls [clst]* busca los archivos que empiecen con c,l,s,t y luego cualquier caracter.
ls [clst][io]?t* busca primero c,l,s,t y luego i,o
rm *tar* $ ls elimina cualquier atchivo tar y tambien los tar.bz2,tar.gz,etc.

ls users-[0-9][a-zA-Z0-9][0-9]* busca primero users-,luego numero del 0 al 9,luego minusculas y mayusculas y luego 0-9 de nuevo 2 veces,luego cualquier caracter

ls users-[0-9][!0-9][a-zA-Z]* el ! niega ese set de caracteres.
[aeiouAEIOU] buscar vocales
[A-Z] todas las mayusculas
[0-9] en base 10
[^A-Z] excluye las letras mayusculas. es lo mismo que [!A-Z].

USO DE TR

cat wonderfulfile
This is a very wonderful file

cat wonderfulfile | tr 'a-z' 'A-Z'
THIS IS A VERY WONDERFUL FILE

cat wonderfulfile | tr aeiouAEIOU '*'
Th*s *s * v*ry w*nd*rf*l f*l*.

cat wonderfulfile | tr -d aeiouAEIOU
Ths s  vry wndrfl fl

tr a-z A-Z < employee.txt

cambia minusculas a mayusculas

USO DE GREP

grep pancake randomlines
busca pancake en el archivo randomlines

buscar lineas terminadas en !
grep '\!$' randomlines

grep -ri panda /root
busca panda en el directorio y en los subdirectorios de root.

grep "^Nov 10" messages.1
busca cualquier linea que empiece con Nov 10 con ^

grep "terminating.$" messages
busca cualquier linea que termine en terminating con $

USO DE TEE

copia la entrada como cat y devuelve la salida,pero simultaneamente copia la entrada a uno o mas archivos generalmente, esta entremedio de 2 comandos haciendo un archivo que sera pasado por una tuberia

who | tee original_who | sort

USO DE AWK

imprimir la 2da y 4ta palabra de cada linea con awk
awk '{print $2, $4}' myfile

imprimir las lineas menores a 60 caracteres
awk 'length < 60 {print}' myfile

imprimir un archivo reemplazando me con YOU con sed
sed 's/me/YOU/g' myfile

imprime el archivo sin las primeras 10 lineas
sed '1,10d' myfile

SUBSTITUYENDO TEXTO CON m4

cat substitutions
My name is NAME and I am AGE years old
ifelse(QUOTE,yes,Learn Linux today!)
m4 -DNAME=Sandy -DAGE=25 -DQUOTE=yes substitutions

sustituyendo texto con sed
sed 's/Linux/Linux-Unix/' thegeekstuff.txt

cambia Linux por Linux-Unix en thegeekstuff.txt
sed 's/Linux/Linux-Unix/2' thegeekstuff.txt

cambia linux por linux-unix 2 veces
sed 's/Linux/Linux-Unix/g' thegeekstuff.txt

cambia linux por linux-unix en todo el archivo
sed -e 's/#.*//;/^$/d'  thegeekstuff.txt

eliminar comentarios y lineas en blanco usando ;
comando join:mezcla los numeros de lineas de dos archivos

comando xargs:redirige la salida de un comando como argumento para otro
cat url-list.txt | xargs wget –c

la salida de cat es usada por wget
find ~ -name ‘*.log’ -print0 | xargs -0 rm -f

los archivos .log que va encontrando los va pasando
a rm -f

find /etc -name "*.conf" | xargs ls –l
va viendo los permisos de los archivos .conf con ls -l que va encontrando con find

USO DE SORT

sort -t . -k 1,1n -k 2,2n -k 3,3n -k 4,4n /etc/host
ordena /etc/host por ip

 

Comandos(Programas) en linux

 nl - ver archivos con numero de lineas
cat - ver archivos enteros
less - ver archivo por pagina
head - las primeras lineas de un archivo
tail - las ultimas lineas de un archivo
od - ver archivo en octal(u otros)
strings - busca texto en ejecutables,si se.combina con greps puede dar mejores resultados strings -n 10 /usr/bin/who | grep '@' strings /usr/bin/who
file - reporta el tipo de archivo
du - disc usage

touch - puede cambiar el estampado de tiempo del archivo: touch -d "November 18 1975" myfilemc - midnight commander,un administrador de archivos de linea de comandos.
nautilus y/o dolphin - administradores de archivos graficos.

ALIAS

programa que puede acortar instrucciones
alias ll='ls -lG'...pueden ser agregadas en el archivo bash_aliases. con alias puedes verlos todos.

 who - muestra info detallada sobre las conexiones al
sistema. puede usarse who -q para simplificar

who | wc -l la barra vertical se llama tuberia y conecta el programa who con wc. pueden usarse multiples. el funcionamiento es mandar la salida a otro programa.
whoami - muestra lo mismo que who,pero solo la info sobre el usuario actual.
finger - muestra info sobre los usuarios del sistema
logout y exit- cerrar la sesion y cerrar terminal respectivamente
info - a diferencia de man,presenta info de forma jerarquica
man  paginas de manual sobre un programa,generalmente se.instalan junto con el programa
mount - mount -t typedevice dir
las unidades /dev/cdrom/ y /dev/sdb1 estan asociadas a los CDROM y USB respectivamente
mount /dev/cdrom /mnt - ej de montaje

cd usado sin argumentos te lleva a tu carpeta personal
ls /bin muestra /usr/bin
ls $HOME cuenta los elementos de HOME
df -h / muestra el espacio de tu disco duro
top -d1 muestra los procesos
last -1 $USER muestra tu nfo de logeo
whois hace whois a una pagina
wget descarga algo sin usar el navegador
wget -c http://URL reinicia una descarga incompleta
wget -b http://URL descarga en bg y puede consultarse usando tail -f wget-log

wget --user-agent="Mozilla/5.0 (X11; U; Linux i686; enUS;rv:1.9.0.3) Gecko/2008092416 Firefox/3.0.3" URL .Algunos sitios no dejan descargar sin navegador,para prevenir esto se usa --user-agent

wget --limit-rate=200k limita el uso de bandaancha
wget --spider DOWNLOAD-URL comprueba la URL
wget -i download-file-list.txt descarga multiples URL
wget -o download.log DOWNLOAD-URL escribe la output(stderr) a download.log
ftp usuario@servidorftp conectarse mediante ftp
ip addre sho eth0 wlan0..muestra info de un dispositivo de red

(files | directory) significa eleccion,tal cual
man -k database busca manpages con la keyword database
man -k database | less no vuelca todos los resultados
wc -lw myfile es lo mismo que -l -w
ls . otracarpeta - lista el directorio actual+otracarpeta

mkdir $HOME/notas crea una carpeta notas.Vease que solo lo hara si $HOME existe $HOME es igual a ~, si pones cd ~fred te mueve a la carpeta personal fred siempre que el usuario fred exista.

$HOME/notas es igual a ~/notas

lpr /etc/hosts/ imprime el archivo hostS
ls -lG /proc/version/ muestra info del archivo.Los archivos de la carpeta /proc/ tienen propiedades especiales,pesan 0 y son solo de lectura.
cat /proc/version muestra magicamente info del kernel
/proc/ioports hardware de entrada/salida de tu pc
/proc/cpuinfo/ info de los procesadores de tu pc
/proc/uptime/ puede usarse uptime tambien
/proc/nnn/ info acerca del proceso nnn,donde nnn va un numero positivo

el cmd type permite saber si un comando es propio de la shell o no.
type who :origen desde /usr/bin
type cd  :cd is a shell builtin..propio de la shell

SCREEN
el programa screen se usa para abrir multiples (multiplexar) procesos que abren el terminal. solo se puede tener 1 tarea en primer plano,para poner mas hay que usar el comando screen,que da 10 ventanas para ejecutar fg del 0 al 9.

para ponerle un nombre a una sesion se usa screen -S nombresesion ,para terminar una shell usamos ctrl+a o escribir exit,tambien interrumpe los trabajos.

para ver las shell se usa screen -r
para cambiar a otra shell se usa screen -r numeroshell para matar un proceso hay que llevarlo a fg y usar ctrl+c

Enlaces Simbolicos

 ENLACE SIMBOLICO

Para crear uno se usa ln. existen dos tipos de enlaces soft and hard.

ln -s archivo enlacearchivo enlace suave o simbolico
ln archivo enlacearchivo enlace duro.

los enlaces suaves son como los atajos de windows o los alias de macOS.
si eliminas el programa original,el enlace suave deja de ser util,en cambio el enlace duro seguirá funcionando

para saber donde apunta un enlace simbolico, se puede
usar el programa readlink o ls -l link

Uso de diff. Comparar JPEGS y TXTS

 SUSTITUCION DE PROCESOS(Redireccionamiento)
supongamos que queremos comparar cada jpeg con su  correspondiente txt

ls jpegexample  file1.jpg  file1.txt  file2.jpg  file2.txt ...  y quieres confirmar que cada jpeg tiene su fichero  txt y viceversa
Lo que haces es crear una carpeta  con los JPEGS y los TXT 
ls *.jpg | cut -d. -f1 > /tmp/jpegs  ls *.txt | cut -d. -f1 > /tmp/txts 
y luego comparar ambas carpetas con diff 
diff /tmp/jpegs /tmp/texts 
usando el redireccionamiento puedes hacerlo todo en  una linea: 
diff <(ls *.jpg|cut -d. -f1) <(ls *.txt|cut -d. -f1)  y sin mover los archivos

Sobre la shell

 

 ¿Que es una shell? Pues no es nada mas que un interprete de comandos que funciona a traves de terminal. Se puede diferenciar usando bash sobre Qterminal, por ejemplo.

 echo $BASH muestra la shell que estas usando la mas  usual es bsh (bourne shell).  el cmd chsh puede ayudar a cambiar la shell,siendo  root puede cambiarle la shell a cualquier usuario. un  usuario normal solo puede cambiar la shell de su  cuenta. 

usando more shells en /etc/ nos encontramos 

 # /etc/shells: valid login shells  

/bin/sh
/bin/bash
/usr/bin/bash 
/bin/rbash 
/usr/bin/rbash
/bin/dash
/usr/bin/dash
/bin/zsh
/usr/bin/zsh
/usr/bin/tmux
/usr/bin/screen  
vease que sh,bash,rbash,dash,zsh son de la carpeta bin  .

se pueden definir variables como $BASH usando linux=3 y luego  echo $linux en consola. Vease que linux distingue entre mayusculas y minusculas. existen variables predefinidas por  la shell como $DISPLAY,$HOME,$LOGNAME,$MAIL,$USER,  $TERM,etc. Para verlas todas hay que usar printenv  o set,o set -o, o echo  printenv muestra todas las variables  set muestra todas las variables 
echo $HOME - Muestra el valor de $HOME 
printenv HOME - lo mismo que echo $HOME 

para cambiarle el valor a una variable durante el uso  de un programa una vez:  printenv HOME: /root  HOME=/kalo printenv HOME  esto a su vez sin cambiar el valor original /root

VARIABLE $PATH
cuando se usa who,linux busca.en los directorios por el programa usando PATH. con echo $PATH se puede saber cuales son;

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/system/xbin:/system/bin

se puede agregar o modificar un directorio usando PATH=$PATH:/usr/share/doc ...por ejemplo,pero este cambio sera solo temporal. para hacerlo definitivo hay que modificar .bash_profile.

 

CONTROL DE TAREAS EN EL SHELL

jobs - mira las tareas actuales
& - manda un proceso a background,al fondo,2do plano  . se hizo para no tener que esperar a que termine un  proceso en 1er plano para iniciar otro.
suspend - suspender una concha
nohup ./my-shell-script.sh &  con nohup se evita que la orden sea asesinada cuando  hagamos logout de nuestro usuario
at -f backup.sh 10 am tomorrow  ejecuta el script mañana a las 10am  
watch -n 60 df -h  ejecuta cada 60segundos df -h,-n y --interval va con  los segundos para que la orden se ejecute periodica%
fg %ntarea- traer proceso al primer plano 
bg - traer proceso al 2do plano  nano linux

 con CTRL+Z puedes suspender la tarea del primer plano

REDIRECCION ENTRADA/SALIDA

cmd < infile le damos al comando como entrada el archivo infile
cmd > file ...crear/sobreescribir archivo
cdm >> file ...adjuntar

se puede escribir archivos de error mientras se ejecuta un programa...esto es una derivacion de la entrada en caso de fallar

nano 2> errorfile

la entrada y la entrada de error en diferentes
archivos: nano > outfile 2> errorfile

nano >& en un mismo archivo
nano &> en un mismo archivo

no queremos la salida standard,stderr,,solo si hay salida de errores

cat file.txt > /dev/null
./shell-script.sh > /dev/null

si no queremos ver la salida de errores

cat invalid-file-name.txt 2> /dev/null
./shell-script.sh 2> /dev/null

Ejecutar procesos paralelos
command1 ; command2 ; command3

Parar el resto de procesos si el anterior falla:
command1 && command2 && command3

para ejecutar comandos y parar la ejecucion tan pronto como uno finaliza: command1 || command2 || command3

una coma interpreta literalmente: echo '$HOME'
dos comas los interpreta como comandos echo "$HOME"
`` y $() se interpretan como comandos

pero $() es mejor porque puede anidar $(expr $(date +%Y) + 1)
usando \ se puede hacer una expresion literal:
echo a\* * deja de ser un comodin y es un asterisco

echo "\$HOME" $ se vuelve solo el signo dolar

linux tiene su propio historial y tiene los siguientes comandos.

!! corre el comando anterior
history - muestra el historial
history -C - borra el historial
history N - muestra el comando N usado
!N - reejecuta el comando N
!-N - reejecuta el comando -N?
!$ - ejecuta el parametro del comando anterior
ls asdf* asdf1 asdf2 asdf3
rm !$ ..lo que es igual a rm asdf*

PROCESOS

son programas,comandos o ejecutables. los procesos demonio son los que estan permanentemente en el sistema. siempre se esta ejecutando y esperando queel usuario haga uso de el. generalmente estos ultimos terminan en d(como crond,httpd,cupsd) todo proceso posee un PID.(process identifier) y todo proceso tiene un padre,excepto el primero que tiene PID 1 el primer proceso se llama init en distros que usan SysV, o systemd en la mayoria de las distros recientes.
ps permite ver los procesos del sistema. de modo predeterminado,solo muestra los iniciados desde la consola. los cmd kill y kill mandan señales a los procesos. kill espera un n de proceso como argumento,mientras que killall espera un comando. por default ambos envian la señal 15

gnome-system-monitor es un administrador grafico que funciona con gnome y kde top permite ver los procesos desde la consola

CODIGO DE RETORNO
todo comando en linux devuelve un codigo al terminar su ejecucion. 0 cuando ha terminado correctamente,diferente de 0 en caso contrario. dependiendo de la razon da un codigo u otro. se usa la.variable $!

ls zergfluf
$!

Fuente: Linux Pocket Guide

Permisos de archivo

 ls -l Se usa para ver los permisos de un archivo
ls -ld Se usa para ver los permisos de carpeta  

-rw-------. 1 root root 6277 Apr 10 01:26 linux 

el primer caracter(-) depende de que es el archivo: 
- para archivos,
d para directorio,
l para enlaces  simbolicos,
p para tuberias,
c para caracteres del  dispositivo,
b para bloques del dispositivo. 
rw- son los permisos del dueño del archivo,en este  caso r(read),w(write). Como sale - en vez de  x(execute) significa que el dueño del archivo no tiene   permiso de ejecutar el archivo.  los siguientes 3 - son los permisos del grupo al que  pertenece, --- significa que para el grupo root no  tiene permiso de read(leer),write(escribir)   y execute(ejecucion).  

los ultimos --- son los permisos para cualquiera que  quiera acceder al archivo y no sea el usuario root o  parte del grupo root.  

-rwx---rwx. 1 root root 6277 Apr 10 01:26 linux  este ultimo ejemplo significa que el usuario root  tiene permisos de leer(r),escribir(w) y ejecutar(x)  y las ultimas rwx son los permisos para desconocidos  .el primer root es el dueño del archivo y el 2do root  que pertenece al grupo root.

mkdir -m 0755 asdf - crea carpeta con permisos
rm -r borra una carpeta vacia
chgrp - cambia el grupo de un archivo
chmod - modif8ca los permisos de un archivo
chown - cambia al dueño de un archivo
chmod a+x filenam todos ganan permiso de lectura 
chmod u+x filename el Usuario gana permiso de  ejecucion 
chmod --reference=file1 file2  los permisos de archivo2 son iguales al del archivo1
chmod 644 - todos pueden leer,pero tu puedes escribir
chmod 600 - privado
chmod 700 carpeta privada
chmod 755 todos pueden leer,tu puedes escribir
ug+rw u significa user y g group....añade read y write.
a-x quita permisos de ejecucion a todos.

Casos Especiales

ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 54192 nov 18  2015
/usr/bin/passwd
el caracter (s) indica que solo se ejecuta con root

ls -l /usr/bin/write
-rwxr-sr-x 1 root tty  19584   7 sep 13:05
/usr/bin/write
el caracter(s) indica que solo se ejecuta bajo la identidad de su grupo,en este caso,tty.

ls -ld /tmp
drwxrwxrwt 22 root root 4096 ago  3 20:36 /tmp
el caracter(t) bajo el dominio de otros significa que solo el dueño del directorio y el dueño del archivo creado en TMP pueden eliminarlos.

Directorios de linux

 En linux,los directorios pueden tener categorias,que  representan distintos tipos de archivos 

 /bin/ - viene de binary,que son los programas 
/sbin/ - programas con intencion de ser ejecutado por  /root/  /lib/ - librerias usadas por programas 
/doc/ - documentacion  /info/ - documentacion usada por emacs
/man/ - documentacion mostrada por el programa man
/share/ - documentacion especifica de programas,como  ejemplos e instrucciones de instalacion
/etc/ - archivos de configuracion del sistem(y otros)
 

init.d - archivos de conf para el boteo (booting) de  linux
rc.d - archivos de conf para el boteo de linux rc1.d  rc2.d,rc3.d  /include/ - archivos cabeceras .h para programadores

/src/ - codigo fuente para programas
/cgi-bin/- scripts/programas que corren en paginas web
/html/ - paginas webs
/public_html/ - paginas webs
/www/ - paginas webs
/fonts/ - fuentes
/x11/ - x windows archivos del sistema
/dev/ - archivos de dispositivos para interactuar con  discos y otro hardware
/media/ - punto de montaje,carpeta que da acceso a un  disco 
/mnt/ - punto de montaje,carpeta que da acceso a un  disco 
/var/ - archivos especificos de tu sistema,creados y  actualizados con la ejecucion de estos 
/lock/ - archivos bloqueados por el programa para decir  "estoy ejecutando", la existencia de uno puede  prevenir que otro programa,u otra instancia del mismo  ejecute una accion
/log/ - archivos que rastrean eventos del sistema 
/mail/ - carpeta para correo entrante
/run/ - archivos ue contienen la ID de los procesos
/spool/ - archivos en cola como correo saliente,  impresoras,etc 
/tmp/ - almacenamiento temporal para programas o  personas 
/proc/ - describe los procesos activos 
/usr/local - archivos creados localmente por  organizaciones o tu pc
/usr/games - juegos  /bin es mas importante que /usr/bin porque esta mas  cerca del fichero raiz / y lo mismo pasa con /lib  y /usr/bin  /usr/share/doc/ info adicional sobre programas  /boot/ - archivos del inicio del sistema

Archivos en linux

Existen 7 tipos de archivos en linux, los 3 mas importantes son: archivo,directorio y soft link.los otros son archivos que apuntan a un dispositivo de tipo bloque,archivos que apuntan a un dispositivo de tipo caracter(ambos presentes /dev/), archivos de tuberia llamado 'named pipe' para comunicacion entre procesos, archivos socket.

linux tiene 4 partes principales  

kernel - la parte mas baja del sistema operativo. toma  archivos,discos,redes,etc. la mayoria de los usuarios  rara vez se enteran del kernel.  programas - facilitan las tareas.

  shell (concha,caparazon) - Es una UI(interfaz del  usuario) para escribir y ejecutar comandos. Y muestra  los resultados. linux posee bash,csh,zsh,etc. En  cualquier caso las interfaces son similares entre si.  La concha es un intermediario entre el kernel y el  usuario.La shell NO ES el programa grafico llamado  terminal,sino quien lee y ejecuta comandos.  

x(X11) - sistema grafico que otorga ventanas,iconos,  menus y elementos GUI(graphic user interface). Los  mas populares son KDE y GNOME.  linux posee ademas entrada/salida. el programa wc  por ejemplo,acepta como entrada un archivo y  produce salida en la pantalla. ademas de I/O tiene un  flujo para mostrar errores. Normalmente la entrada es  un archivo o una entrada estandar,que suele ser el  teclado. La salida puede ser un archivo o una salida  estandar, usualmente son la pantalla o ventana de la  concha.  .  en terminal es tu directorio actual  .. en terminal es la carpeta superior  se pueden escribir ficheros .sh y luego ejecutarlos  usando bash.

teclas de acceso rapido

mayus+repag o avpag avanza o retrocede mas que estas por si solos.
CTRL+END llegar hasta el final de un texto.
END por si solo avanza hasta el fin de linea.
CTRL+HOME llegar hasta el principio de un texto.
HOME por si solo retrocede hasta el principio de una linea.
con SHIFT+TAB puede completarse una palabra buscada en la linea de comandos ademas puede usarse el comodin * para completar busquedas: puede hacer rm a* y eliminara todos los archivos que empiecen con a y sigan con cualquier cosa

Solo hecho en NANO.
ctrl+s guardar sin confirmar
ctrl+w borra toda la palabra, en nano busca
ctrl+u borra toda la linea
ctrl+d desconectarse de la terminal

inodos

 los inodos son los metadatos de un archivo. Solo los S.O de linux tienen inodos. Los sistemas de archivos que usan inodos son ext2/3/4. Los inodos son estructuras de datos que almacena info sobre un fichero de nuestro sistema de archivos. Inodos no tienen nombre,se identifican con un numero entero unico. Las carpetas tambien tienen inodo.
Los metadatos que almacena un inodo son: n de inodo,tamaño del fichero, dispositivo de almacenamiento,n de enlaces,uid,gid,timestamps:ultimo acceso, fecha en que se ha creado el archivo,tabla de direccionamiento: estan detallados los bloques del disco duro donde estan almacenados los ficheros.

usando el comando stat podemos ver la info almacenada por el inodo 606065

File: linux
Size: 5941            Blocks: 16         IO Block: 4096   regular file
Device: fd0ah/64778d    Inode: 606065      Links: 1
Access: (0600/-rw-------)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2022-04-05 14:45:05.461557661 +0000
Modify: 2022-04-08 18:32:30.697426708 +0000
Change: 2022-04-08 18:32:30.697426708 +0000
Birth: -

la principal funcion de la info en el inodo es acceder a la info almacenada en nuestro disco duro.

11-04

las dentries son los inodos de un directorio. las dentries de un directorio se almacenan en una tabla. Es decir,una dentry es un nombre que apunta hacia un inodo. Usa un inodo por cada directorio incluyendo /. usa una dentries para unir cada archivo con su carpeta, los subdirectorios con directorios(..) padre y estos con / al final.

para saber el espacio que ocupa un inodo debe usarse fdisk -l ,luego tune2fs -l /dev/sdax | grep Inode
los sistemas de archivos ext4 acostumbran a tener 256 bytes como tamaño de inodos. el ext2 acostumbra tener 128 bytes.

si la particion /home es de 256 bytes y los bloques de mi disco duro son de 4096 bytes,cada bloque del disco duro podra almacenar 16 inodos.

Los inodos se crean en el momento que se genera el sistema de archivos. Una vez generado el sistema de archivos no será posible añadir y/o redimensionar los inodos. en los sistemas de de archivo jfs,btrfs, y xfs si se permite incrementar la cantidad de inodos.

Si queremos controlar el número y el tamaño de los inodos lo podemos hacer en el momento de formatear nuestras particiones:

mkfs.ext4 -N 2.000.000 -I 256 /dev/sdaX

si usamos este comando se formateara la particion creando 2 000 000 de inodos con 256 bytes de tamaño c/u. Hay que tener ciertas precauciones:

El tamaño de los inodos tiene que ser una potencia de 2 igual o mayor que 128 bytes. Los tamaños de inodo recomendados son 128 o 256 bytes.

El número de inodos ideal será en función del tamaño de la partición y de las necesidades de cada usuario.

Si eligen un tamaño de inodo muy grande y/o una gran cantidad de inodos, se reducirá la capacidad de almacenamiento del disco duro

Existen parámetros adicionales para controlar el número de inodos generados como por ejemplo -i bytes-per-inode, -T usage-type[,…], etc

para formatear rapidamente la particion se usa mkfs.ext4 /dev/sdaX
los inodos contienen bloques para almacenar las posiciones del contenido del fichero en el disco duro. si el inodo llena la tabla se realiza un direccionamiento indirecto...que es llamar una nueva tabla de bloques hacia mas posiciones de nuestro disco. Del mismo modo que se hacen direccionamiento simples pueden hacerse dobles o triples. Con esto se pueden sacar unas cuantas conclusiones: el acceso a los archivos será más lento cuando se hace un direccionamiento indirecto.

Podremos acceder de forma mucho más rápida y eficiente en archivos de poco tamaño. Por este motivo los sistemas de archivos basados en inodos son ideales para manejar servidores web o servidores de email. en linux se hace referencia a un archivo por su inodo,no su nombre.

para ver la cantidad de inodos usados se usa df -i
para ver el numero de inodos de una carpeta ls -i
lo mismo para cualquier archivo: ls -i /ruta/inodo
para encontrar un archivo por su inodo se usa find / -inum 523580