aken
/
howtos
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Poblando el git

This commit is contained in:
aken 2023-07-12 11:41:35 +00:00
parent 5278942cd6
commit 6ecc61fb8b
141 changed files with 9503 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

579
BANANA PI GATEWAY.txt Normal file
View File

@ -0,0 +1,579 @@
*****************************************************************************
*****************************************************************************
**************** BANANA PI GATEWAY *****************************************************************************
*****************************************************************************
http://www.awasu.com/weblog/bpi-gateway/
*****************************************************************************
*****************************************************************************
First, activate the WiFi module:
sudo modprobe bcmdhd
Second, connect to WiFi network
With interative commands:
sudo ip link set wlan0 up
sudo -s
wpa_passphrase <SSID> > /etc/wpa_supplicant.conf (write the password and push enter)
wpa_supplicant -i wlan0 -c /etc/wpa_supplicant.conf
sudo dhclient wlan0
sudo ip route change default via <gateway ip> dev wlan0
Connect at boot:
nano /etc/network/interfaces
delete '#' fron auto wlan 0
=============================== Setting up the Gateway ========================
We now have our Banana Pi up and running with a clean installation of Bananian Linux. To get it working as a gateway, we need to do 3 things:
set up a DHCP server, so that computers can join the network.
set up a DNS server, so that domain names can be resolved.
set up NAT, so that internet requests can be made on behalf of other computers on the network.
Once you've set up these 3 things, you will have a basic gateway up and running, and other computers on the internal network should have internet access.
The diagram below shows how it all fits together:
When a new computer[1] joins the network, it will contact the DHCP server running on the bPi to get an IP address. As part of this assignment, the bPi will tell the new computer that it also handles DNS requests, as well as any other internet activity.
If someone wants to go to a web site, they will ask the DNS server to look-up the domain name, to get the web site's IP address.
Finally, NAT ensures that internet requests go out, and replies come back in, transparently.
=============================== Setting up DHCP ===============================
Every computer on a network has a unique ID, known as an IP address, which might look something like 72.249.26.4. Back in the day, a network administrator would have to go around and configure these manually for every single computer on a network, but with the advent of DHCP[1], this can now be done automatically.
When a computer is turned on, and has been configured to use DHCP, it checks the network to see if a DHCP server is available and if so, asks it for an IP address. The DHCP server has a pool of IP addresses it can use, and if one is available, assigns it to the new computer, which can then use it to identify itself and communicate with other computers on the network. When the computer is turned off, its IP address is released and becomes available for use by another computer.
Installing and configuring the DHCP server
So, we need to install a DHCP server on our gateway, so that computers on our internal network can get IP addresses[2]. This is very simple:
sudo apt-get install isc-dhcp-server
It will probably fail when it tries to start up, because it hasn't been configured yet, but we can ignore this, since we will configure it now.
First, edit /etc/default/isc-dhcp-server and set the INTERFACES parameter. For example, in my home network, I connect to the internet via wifi (i.e. the wlan0 network interface), and use the wired network for my LAN, so I would set this to eth0[3].
Then edit /etc/dhcp/dhcpd.conf:
Set the domain-name option to what you would like to call your network e.g. gateway.
Set the domain-name-servers option to the IP address of the bPi[4].
Add a line to set the routers option, that configures the IP address of the gateway[5].
Un-comment the authoritative statement.
Configure the lease addresses[6] e.g.
subnet 10.0.0.0 netmask 255.255.255.0 {
range 10.0.0.100 10.0.0.199 ;
}
It is also possible to assign specific computers a fixed IP address, according to their MAC address e.g.
host mycomputer {
hardware ethernet XX:XX:XX:XX:XX:XX ;
fixed-address 10.0.0.2 ;
}
Restart the service:
sudo service isc-dhcp-server restart
We also want it to start up when the system is booted:
sudo update-rc.d isc-dhcp-server start
Finally, to check what IP addresses have been assigned, take a look inside /var/lib/dhcp/dhcpd.leases.
=============================== Setting up DNS ================================
Every computer is uniquely identified by an IP address, but these are inconvenient, and it's much easier to refer to them by name. The Domain Name System is a network's white pages, but instead of looking up somebody's name in order to get their telephone number, you can look up a domain name (e.g. awasu.com) and get its corresponding IP address (e.g. 72.249.26.4).
Installing and configuring the DNS server
We need to install a DNS server on our gateway, so that computers on the internal network can do domain name lookups[1].
First, we need to install the DNS server:
sudo apt-get install bind9
We can also install some useful tools that let us do DNS lookups from the command line (e.g. dig and nsupdate):
sudo apt-get install dnsutils
Now, computers on my internal network will have their DNS lookups done by the DNS server running on our gateway[2].
However, the gateway DNS server itself needs to do DNS lookups, and this is configured in /etc/resolv.conf. In the case of my home network, I get given the address of a DNS server when I connect via wifi, but you might want to use something else e.g. 8.8.8.8, if you want to use Google's DNS servers.
=============================== Setting up NAT ================================
Network Address Translation allows the gateway to send requests out to the internet on behalf of computers on the internal network. When the gateway receives an internet request, it tweaks it slightly to make it look like it was sending the request itself, and then forwards it on to the intended recipient on the internet. When the reply comes back, they gateway tweaks it again to make it look like nothing happened i.e. the computer on the internal network thinks it was communicating directly with the remote computer on the internet.
To set this up, we first need to enable IP forwarding in the kernel. Edit /etc/sysctl.conf and uncomment the net.ipv4.ip_forward=1 line.
To reload these settings:
sudo sysctl -p /etc/sysctl.conf
We also need to enable IP masquerading:
sudo iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE
This command tells the gateway to forward any internet requests to the wlan0 interface i.e. my wifi connection, which is how I connect to the internet.
Since we need this to always happen, the above command should be added to /etc/rc.local.
=============================== Setting up a WiFi access point ================
Installing the WiFi adapter
The Banana/Raspberry Pi's are very finicky when it comes to WiFi adapters 🙁 so you need to do some research before buying one. A list of wifi adapters known to work with a Raspberry Pi can be found here, and Mikronauts have done some research on adapters that work with a Banana Pi.
I chose a TP-Link TL-WN723N.
After plugging it in, lsmod showed that the 8188eu driver had been loaded for it:
lsusb also showed it connected:
Configuring the access point
First, we want to give the wifi adapter a fixed IP address, so add the following to /etc/network/interfaces[1]:
allow-hotplug wlan1
iface wlan1 inet static
address 10.0.1.0
netmask 255.255.255.0
Next, we need to install hostapd, that will allow the bPi to function as an access point:
sudo apt-get install hostapd-ap6210
Configure hostapd by editing /etc/hostapd/hostapd.conf and changing the following settings:
interface = wlan1
ssid = ...YOUR SSID NAME...
wpa_passphrase = ...PASSWORD...
Now we can run hostapd:
sudo hostapd -B /etc/hostapd/hostapd.conf
If hostapd doesn't work
If you get a "invalid/unknown driver 'nl80211'" error[2], nl80211 driver support is not available and we will have to compile hostapd from source.
First, install the packages needed to compile:
sudo apt-get install gcc git make
sudo apt-get install libnl-3-dev libnl-genl-3-dev openssl libssl-dev pkg-config
Then, get the source for hostapd:
cd /tmp
git clone git://w1.fi/srv/git/hostap.git
Then, configure it:
cd hostap/hostapd
cp defconfig .config
Edit .config and make sure that CONFIG_DRIVER_NL80211=y and CONFIG_LIBNL32=y are active i.e. not commented out.
Then, compile and install it:
make
sudo cp hostapd /usr/sbin/
If hostapd still doesn't work 😐
In my case, it turns out I need to use a customized version of hostapd provided by RealTek :wall: Fortunately, Jens Segers has done some work to make this process easier.
If you already installed the distro hostapd, remove it:
sudo apt-get autoremove hostapd
Install the packages needed to compile:
sudo apt-get install gcc make
sudo apt-get install openssl libssl-dev
Get the source for the customized hostapd:
cd /tmp
wget https://github.com/jenssegers/RTL8188-hostapd/archive/v2.0.tar.gz
tar -zxvf v2.0.tar.gz
Compile hostapd:
cd RTL8188-hostapd-2.0/hostapd
make
sudo make install
Configure hostapd.conf as described above, then try to start it:
sudo service hostapd start
Configuring DHCP
Hopefully, you should be able to connect to the access point, so we now need to update our DHCP server to assign IP addresses to any computers connecting via WiFi.
Edit /etc/default/isc-dhcp-server and add the new interface to INTERFACES.
Edit /etc/dhcp/dhcpd.conf and add another subnet entry e.g.
subnet 10.0.1.0 netmask 255.255.255.0 {
range 10.0.1.100 10.0.1.199 ;
option domain-name-servers 10.0.0.1 ;
option routers 10.0.0.1 ;
}
Then restart the DHCP service:
sudo service isc-dhcp-server restart
You should now be able to connect to the access point, be given an IP address, and get online.
=============================== Setting up DNS-based ad-blocking ==============
Ad-blocking is becoming more of a necessity these days, and while there are many browser plugins that will strip ads, they can be slow and memory-hungry. Blocking ads via DNS is an interesting alternative, that can work along-side browser-based solutions, and because it's done on the gateway, any computer that connects to the internet via the gateway will benefit from it.
Normally, when a browser wants to load an ad from, say, annoyingads.com, it will do a DNS lookup on that domain name to get its IP address, and then send a request to that IP address to get an ad:
However, since we are running our own DNS server, we can circumvent this process by returning something different for the IP address. If we set up a dummy web server and return the IP address of that[1], when the browser tries to load an ad, it will connect to that instead of the real server. If we configure the dummy web server to return blank images, then all we will see in the web page is empty space, rather than ads.
Installing the web server
Download the daemon version of pixelserv from here and save it somewhere e.g. /root/bin/pixelserv.pl.
Make sure it's executable, then run it:
sudo chmod 755 pixelserv.pl
sudo ./pixelserv.pl
Open a browser and go to http://10.0.0.1 - you should receive a 1x1 image.
Setting up the DNS blacklist
Save the script below somewhere (e.g. /root/bin/get-dns-blacklist.sh), which downloads a list of domains known to serve ads:
curl "http://pgl.yoyo.org/adservers/serverlist.php?hostformat=bindconfig&showintro=0&mimetype=plaintext" \
| sed -e "s/null.zone.file/\/etc\/bind\/db.pixelserv/" \
>/etc/bind/zones.blacklist
service bind9 reload
Make sure it's executable, then run it:
sudo chmod 755 get-dns-blacklist.sh
sudo ./get-dns-blacklist.sh
Check that the zones blacklist file (/etc/bind/zones.blacklist) was created and populated.
Create a zone file e.g. /etc/bind/db.pixelserv:
$TTL 86400 ; one day
@ IN SOA ads.example.com. hostmaster.example.com. (
2001010100 ; serial number YYYYMMDDNN
28800 ; refresh 8 hours
7200 ; retry 2 hours
864000 ; expire 10 days
86400 ) ; min ttl 1 day
NS my.dns.server.org
A 10.0.0.1
@ IN A 10.0.0.1
* IN A 10.0.0.1
Then, add an entry to /etc/bind/named.conf.local:
include "/etc/bind/zones.blacklist" ;
Test the ad-blocker
The DNS server should still be running with the old settings, so if we do a DNS lookup on a blacklisted domain, it should still resolve to the real IP address:
Now, if we restart the DNS server:
sudo service bind9 restart
and run the same query again, we can see that the returned IP address is different, and the domain name is now pointing to us.
This means that any attempt to connect to 101com.com will actually connect to our pixelserv web server, and any attempt to retrieve an ad will receive a 1x1 image instead.
Configuring the ad-blocker to run at system startup
We want pixelserv to run at startup, so we can add it to /etc/rc.local:
# start pixelserv
/root/bin/pixelserv.pl &
Note the trailing ampersand, which tells the script to run in the background, so that the startup script doesn't block, waiting for it to finish.
We also want to regularly download the latest blacklist, so we schedule a cron job to run the download script:
sudo crontab -e
In the screenshot, I've set the job to run at 3am every day, and to log the output, in case there are problems.
=============================== Setting up OpenVPN ============================
A virtual private network gives you better security and privacy as you work online. An encrypted connection to a VPN server is created, and all your internet traffic is sent over that connection, where it is forwarded on to the real destination by the VPN server. Anyone snooping on your internet traffic will be able to see that you are using a VPN, but will not be able to decipher any of it, due to the encryption.
Installing and configuring OpenVPN
By far, the most popular open-source VPN software is OpenVPN, and to install it:
sudo apt-get install openvpn
Your VPN provider will supply you with configuration files (usually with a .ovpn extension) for connecting to their servers. Save these in /etc/openvpn/.
You will also be given a username and password - put these in a password file (e.g. /etc/openvpn/auth) with the username on the first line, and password on the second line.
We also need to change NAT so that internet requests are forwarded on to the VPN tunnel, instead of the normal network interface:
sudo iptables -t nat -A POSTROUTING -o tun0 -j MASQUERADE
Now we can run OpenVPN[1]:
sudo openvpn \
--cd /etc/openvpn/ \
--config XXX.ovpn \
--auth-user-pass /etc/openvpn/auth \
--auth-nocache \
-keepalive 10 60
You can check your external IP address like this:
wget http://ipinfo.io/ip -qO -
Or just fire up a browser and go to http://ipinfo.io.
Configuring OpenVPN to run at startup
To get OpenVPN to run at startup, you need to change[2] the iptables command to forward internet requests to the tun0 interface instead of wlan0 (as described above).
Then, add the openvpn comand you used above, but with an extra --daemon parameter, so that it will run in the background.
=============================== Setting up an email relay =====================
Email is messy. It's often useful to have programs send emails[1], so rather than forcing everyone to deal with the messiness themselves, it's often easier to set up an email relay. This is a program that runs on the gateway and accepts email from computers on the internal network, then forwards them on to the real recipients on the internet.
Unfortunately, if we just send out the email ourself, there is virtually no chance of it reaching its destination, since most mail servers will not accept email from other servers unless they meet some stringent requirements[2]. So, the best way for our relay to forward emails is to forward them on again to another email server, one that is known to be acceptable to the internet at large, and have it send the email to the real recipient.
Installing and configuring the mail server
A popular mail server is exim4, and installing it is easy:
sudo apt-get install exim4
Edit[3] /etc/exim4/update-exim4.conf.conf and set the following options:
dc_eximconfig_configtype = 'satellite'[4]
dc_other_hostnames = ''
dc_local_interfaces = '10.0.0.1'[5]
dc_readhost = 'gateway'[6]
dc_smarthost = 'myserver.com'[7]
dc_hide_mailname = 'true'
dc_relay_nets = '10.0.0.0/24'[8]
Edit /etc/mailname and put in the host name of the gateway machine.
Your email server will almost certainly require authentication, so edit /etc/exim4/passwd.client and set the login details there e.g.
myserver.com:USERNAME:PASSWORD
Finally, edit /etc/email-addresses and set the email addresses you want to use when sending emails from each user account e.g.
taka: taka@myserver.com
root: root@myserver.com
This means that if I send an email when logged on as taka, it will appear to have come from taka@myserver.com, or root@myserver.com if I am logged on as root.
Now everything has been configured, we can install the new settings and restart the server:
sudo update-exim4.conf
sudo /etc/init.d/exim4 restart
Testing the email relay
Open a new console window and monitor the exim4 log file:
sudo tail -f /var/log/exim4/mainlog
Back in the original console, install the command-line email program and send a test email:
sudo apt-get install mailutils
echo body | mail -s "relay test" me@somewhere.com
In the exim4 log, you should see it receive the email, forward it on, and a few seconds later, hopefully receive it at the final email address.
A warning about relaying email
We have configured our relay to not require any login, so we need to be very careful about restricting access to it - spammers just love it when they find an open email relay 🙁 Above, we configured dc_relay_nets so that we only relay emails from computers on our internal network, and you should also control access via the firewall, so the only danger is if one your computers in your internal network gets compromised, since it will be able to send out emails without restriction. Keep an eye on your logs!
=============================== Setting up a firewall =========================
Of all the extra services we can have on our gateway, a firewall is the most useful and should be considered mandatory. In this section, we will block all incoming and outgoing traffic, and then selectively enable only the traffic we want to allow e.g. web browsing, email, etc.
Before we start, it's important to understand the different types of messages that can be sent over a network:
TCP messages
These are sent between two computers who have set up a connection between themselves, and are usually request/response i.e. one computer sends the other one a message, which then sends back a reply.
UDP messages
These are "shouted out" on the network, to whoever might be listening[1]. In this case, there is no concept of request/response, it's just computers broadcasting messages to the network to whoever might be there.
ICMP messages
These are low-level messages that computers send to each other to pass information about the state of the network itself.
We will use the iptables program to manage the firewall, which uses tables and chains. A chain is just a list of rules that are checked, in order, to see if a message should be allowed through, or blocked. There are several standard tables, but we will only be using the following:
filter
This table is used when checking whether to allow packets in or out, and has the following chains:
INPUT: a list of rules that control what packets are allowed in
OUTPUT: a list of rules that control what packets are allowed out
FORWARD: a list of rules that control what packets can be forwarded on
NAT
This table is used to control NAT, and we will use only the following chain:
POSTROUTING: allows packets to be modified after they have been routed
So, for example, if a program running on a computer on the internal network wants to send out an email, it must go through the gateway[2], and iptables will go to the filter table and check all the rules in the OUTPUT chain, looking for one that specifies whether outgoing email is allowed or blocked.
Basic configuration
WARNING! It is very easy to lock yourself out of the computer if you make a mistake configuring the firewall. If you're using a keyboard and monitor that have been plugged in, it doesn't matter, but if you're connecting via SSH and accidentally block SSH traffic, you will no longer be able to communicate with the computer!
This is especially bad if you've set the firewall rules to be applied when the system boots up, since even a reboot won't clear the problem - SSH will still be blocked and so the only solution will be to plug in a keyboard and monitor, or restore the SD card from a backup. For this reason, it's a good idea to disable firewall configuration in /etc/rc.local when you're working on it, until you're sure everything is OK.
We will start[3] by configuring the firewall to block everything, and log anything that gets blocked:
# clear out any existing configuration
iptables --flush
iptables --delete-chain
# set the default policy to DROP
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
# TODO: allow selected traffic through
# create a custom chain that logs packets, then drops them
iptables -N LOGDROP
# nb: the first "limit-burst" packets will be logged, then only "limit" per minute
iptables -A LOGDROP \
-m limit --limit-burst 10 --limit 10/m \
-j LOG --log-prefix "iptables: "
iptables -A LOGDROP -j DROP
# log and drop any remaining packets (nb: this must appear last)
iptables -A INPUT -j LOGDROP
iptables -A OUTPUT -j LOGDROP
iptables -A FORWARD -j LOGDROP
The first few lines reset everything, then set the default policy[4] to DROP.
Near the end of the script, we create a custom chain called LOGDROP, and add a rule[5] to it to log the packet[6][7], and then another rule that drops the packet.
At the very end of the script, we add a final rule to each of the filter chains that tell iptables to jump to the LOGDROP chain. In other words, for each packet, iptables will scan a chain looking for a rule that allows or rejects it (we will add these next), but if it doesn't find a match, the last rule tells it to jump to the LOGDROP chain, which will log the packet, and then drop it.
Allowing TCP responses
The first type of traffic we want to allow through are TCP responses. If a request has been issued by a computer on the internal network, we always want to allow its response to come back in:
iptables -A INPUT -p tcp -m state --state RELATED,ESTABLISHED -j ACCEPT
So, we append a rule to the INPUT chain (-A INPUT) that says: for TCP traffic[8] (-p tcp), check the connection's state (-m state) and if it's either ESTABLISHED[9] or RELATED[10], then allow the packet through (-j ACCEPT).
We also add a similar rule to the OUTPUT chain i.e. if we've already allowed a request to come in from outside, then allow the response to go out:
iptables -A OUTPUT -p tcp -m state --state RELATED,ESTABLISHED -j ACCEPT
And also to the FORWARD chain:
iptables -A FORWARD -p tcp -m state --state RELATED,ESTABLISHED -j ACCEPT
Allowing loopback traffic
Next, we allow all traffic on the loopback interface i.e. if a program on the computer is trying to communicate with another program on the same computer, always let that traffic through:
iptables -A INPUT -i lo -j ACCEPT
In other words, append a rule to the INPUT chain (-A INPUT) that says: traffic coming in on the loopback interface (-i lo) should be allowed (-j ACCEPT).
Similarly, we add a rule to the OUTPUT chain that allows all traffic going out on the loopback interface:
iptables -A OUTPUT -o lo -j ACCEPT
Allowing ICMP traffic
ICMP traffic is most commonly known as used by ping, but there's a whole lot more to it than that. In particular, DNS will get slow if you block it, so while there are certain types of attack that can be made using ICMP traffic, for a home gateway, you're probably better off just allowing everything:
iptables -A INPUT -p icmp -j ACCEPT
iptables -A OUTPUT -p icmp -j ACCEPT
iptables -A FORWARD -p icmp -j ACCEPT
Allowing DNS traffic
DNS uses UDP, so to allow outgoing DNS traffic, we need to add a rule that allows UDP messages to go in and out on port 53 :
iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
iptables -A INPUT -p udp --sport 53 -j ACCEPT
However, certain types of DNS traffic uses TCP, so we add a rule that allows TCP traffic to go out on port 53, but only for new connections:
iptables -A OUTPUT -p tcp --dport 53 -m state --state NEW -j ACCEPT
Note that there's no need to add a rule to allow the responses back in, since we added a generic rule earlier that allows all traffic for ESTABLISHED connections.
We add similar rules to allow incoming DNS traffic:
iptables -A INPUT -p udp --dport 53 -j ACCEPT
iptables -A OUTPUT -p udp --sport 53 -j ACCEPT
iptables -A INPUT -p tcp --dport 53 -m state --state NEW -j ACCEPT
Allowing DHCP traffic
DHCP also runs over UDP (on ports 67 and 68), so while we could add rules similar to those we added above for DNS, we want to add an extra restriction: only allow this traffic for computers on the internal network.
My computers connect to the gateway either via wired ethernet (on the eth0 interface) or via WiFi (on the wlan1 interface), so my rules look like this:
iptables -I INPUT -i eth0 -p udp --dport 67:68 --sport 67:68 -j ACCEPT
iptables -I OUTPUT -o eth0 -p udp --dport 67:68 --sport 67:68 -j ACCEPT
iptables -I INPUT -i wlan1 -p udp --dport 67:68 --sport 67:68 -j ACCEPT
iptables -I OUTPUT -o wlan1 -p udp --dport 67:68 --sport 67:68 -j ACCEPT
My gateway computer connects to the internet via the wlan0 interface, but since the rules above are explicitly for the eth0 and wlan1 interfaces, any DHCP traffic on the wlan0 interface will be dropped.
Allowing SSH traffic
I only ever want to SSH in[11] to my gateway computer, from another computer on my internal network, so my rule for SSH traffic looks like this:
iptables -A INPUT -i eth0 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
For safety, I explicitly allow incoming traffic for ESTABLISHED connections, and I also explicitly allow outgoing traffic:
iptables -A OUTPUT -o eth0 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT
These rules are important - if I make a mistake here, I will get locked out! :wall:
Allow incoming HTTP traffic
If you've set up the DNS-based ad-blocker, you will need to allow incoming requests to the pixel server:
iptables -A INPUT -i eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
Allow incoming email traffic
If you've set up email relaying, you will need to allow incoming email:
iptables -A INPUT -i eth0 -p tcp --dport 25 -m state --state NEW -j ACCEPT
Note that it's critical to only allow this traffic from the local network, otherwise somebody from the outside could connect to your mail server and use it to send spam.
Allowing other common traffic
The following rules allow outgoing HTTP/HTTPS traffic[12]:
PORTS=http,https
iptables -A OUTPUT -p tcp -m multiport --dports $PORTS -m state --state NEW -j ACCEPT
Note that we can use descriptive names for the ports[13] and again, we allow outgoing traffic for new connections only, responses are allowed by the generic "allow responses" rule defined earlier.
We also want to allow NTP traffic[14], which runs over UDP:
PORTS=ntp
iptables -A OUTPUT -p udp -m multiport --dports $PORTS -j ACCEPT
iptables -A INPUT -p udp -m multiport --sports $PORTS -j ACCEPT
Note that these rules apply only to traffic that originates on the gateway computer; for traffic that originates on another computer on the internal network, we need to add rules to the NAT table, which we'll do next.
Allowing common traffic over NAT
As described in the section on setting up NAT, we need a rule to enable NAT:
# clear out any existing configuration
iptables -t nat --flush
iptables -t nat --delete-chain
# enable NAT
iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE
We can then allow outgoing traffic[15] for selected services:
PORTS=http,https,pop3,pop3s,imap,imaps,smtp,smtps,587,ssh,ftp
iptables -A FORWARD \
-i eth0 -o wlan0 \
-p tcp -m multiport --dports $PORTS \
-m state --state NEW \
-j ACCEPT
Similarly, we allow UDP traffic for selected services:
PORTS=ntp
iptables -A FORWARD \
-i eth0 -o wlan0 \
-p udp -m multiport --dports $PORTS \
-j ACCEPT
iptables -A FORWARD \
-i eth0 -o wlan0 \
-p udp -m multiport --sports $PORTS \
-j ACCEPT
I also allow web traffic only from my WiFi-connected devices:
PORTS=http,https
iptables -A FORWARD \
-i wlan1 -o wlan0 \
-p tcp -m multiport --dports $PORTS \
-m state --state NEW \
-j ACCEPT
Allowing VPN traffic
If you are running OpenVPN, you will need the following rules to allow it to work:
iptables -A OUTPUT -o wlan0 -p udp --dport 1194 -j ACCEPT
iptables -A INPUT -i wlan0 -p udp --sport 1194 -j ACCEPT
If you are running OpenVPN, any rules that specify the interface you use to connect to the internet (in my case, wlan0), need to be changed to refer to OpenVPN's tunnel interface instead i.e. tun0. The script supplied below takes care of this.
Putting it all together
There are a lot of rules described here, and the situation is complicated by OpenVPN, since the rules are different depending on whether or not you are using it, so I've put together a shell script[16] that takes care of everything, and can either:
disable the firewall
enables the firewall (with OpenVPN running)
enables the firewall (with OpenVPN not running)
You will obviously want to customize the rules for your own situation, but it's a good starting point, and once you've got it working the way you want, add it to /etc/rc.local so that your rules will be applied when the system boots up.
Monitoring blocked packets
At the very beginning of this section, we set things up so that any dropped packets get logged. By default, these appear in /var/log/messages, but since there will be a lot of these messages, it's far more convenient to collect them in a separate file. To do this, create the file /etc/rsyslog.d/iptables.conf that looks like this:
:msg, contains, "iptables: " -/var/log/iptables
& ~
This tells the logging daemon (rsyslogd) to look for messages that contain the string "iptables: " and send them to another file (/var/log/iptables).
Since we've created a new log file, it's a good idea to set up log rotation for it. Create the /etc/logrotate.d/iptables file like this:
/var/log/iptables
{
rotate 7
daily
missingok
notifempty
delaycompress
compress
postrotate
invoke-rc.d rsyslog rotate > /dev/null
endscript
}
Finally, the log file contains a lot of information about each packet that we're usually not interested in, so next script will filter out the less-important stuff and provide an easier-to-read log.
Script filter-iptables.py:
#!/usr/bin/python
# This script extracts key information from the iptables log file.
# Full tutorial is here: http://awasu.com/weblog/bpi-gateway/firewall/
#
# To process the entire log file:
# sudo filter-iptables.py </var/log/iptables
#
# Or to monitor the log file in real-time:
# sudo tail -f /var/log/iptables | filter-iptables.py
# COPYRIGHT: (c) Awasu Pty. Ltd. 2016 (all rights reserved).
# Unauthorized use of this code is prohibited.
#
# LICENSE: This software is provided 'as-is', without any express
# or implied warranty.
#
# In no event will the author be held liable for any damages
# arising from the use of this software.
#
# Permission is granted to anyone to use this software
# for any purpose, and to alter it and redistribute it freely,
# subject to the following restrictions:
#
# - The origin of this software must not be misrepresented;
# you must not claim that you wrote the original software.
# If you use this software, an acknowledgement is requested
# but not required.
#
# - Altered source versions must be plainly marked as such,
# and must not be misrepresented as being the original software.
# Altered source is encouraged to be submitted back to
# the original author so it can be shared with the community.
# Please share your changes.
#
# - This notice may not be removed or altered from any
# source distribution.
import sys
import os
import re
import time
# ---------------------------------------------------------------------
# This table defines log messages we want to filter out.
IGNORE_RULES = [
{ "proto": "UDP" , "in": "eth0" , "dpt": (137,138) } , # NetBIOS
{ "proto": "UDP" , "out": "eth0" , "dpt": (137,138) } , # NetBIOS
{ "proto": "UDP" , "in": "eth0" , "dpt": (67,68) } , # DHCP
{ "proto": "UDP" , "out": "eth0" , "dpt": (67,68) } , # DHCP
{ "proto": "UDP" , "in": "wlan1" , "dpt": (67,68) } , # DHCP
{ "proto": "UDP" , "out": "wlan1" , "dpt": (67,68) } , # DHCP
]
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
def check_rule( rule , vals ) :
""" Check if an ignore rule matches a log message. """
for val_name,target_vals in rule.items() :
if not vals.has_key( val_name ) :
return False
if type(target_vals) not in (tuple,list) :
target_vals = [ target_vals ]
target_vals = [ str(v) for v in target_vals ]
if vals[val_name] not in target_vals :
return False
return True
# ---------------------------------------------------------------------
def make_addr( ip_addr , port_no ) :
if ip_addr and port_no :
return ip_addr + ":" + port_no
if ip_addr :
return ip_addr
if port_no :
return ":" + port_no
return ""
# ---------------------------------------------------------------------
while True :
# read the next line
line_buf = sys.stdin.readline()
if not line_buf : break
vals = { mo.group(1).lower(): mo.group(2) for mo in re.finditer( "([A-Z]+?)=(\S*)" , line_buf ) }
vals["_timestamp_"] = line_buf[:15]
vals["_src_"] = make_addr( vals.get("src") , vals.get("spt") )
vals["_dest_"] = make_addr( vals.get("dst") , vals.get("dpt") )
# filter out entries we're not interested in
if any( check_rule(r,vals) for r in IGNORE_RULES ) :
continue
# output the next line
print "{_timestamp_} | proto={proto:4} in={in:5} out={out:5} src={_src_:21} dest={_dest_:21}".format( **vals )
0

41
BBDD/Cosas variadas de MYSQL.txt Normal file
View File

@ -0,0 +1,41 @@
===== PONER PASSWORD DEL ROOT ==================================================================================================
$mysql
grant all privileges on *.* to root@'localhost' identified by 'sesamo' with grant option;
===== OBTENER TAMAÑO DE BASES DE DATOS =========================================================================================
SELECT table_schema AS "Base de datos",
ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS "Tamaño (MB)"
FROM information_schema.TABLES
GROUP BY table_schema;
===== VOLCAR BASE DE DATOS PARA BACKUP =========================================================================================
--- Vuelco normal
sudo /usr/bin/mysqldump -u root [BASE_DE_DATOS] > /mariadb-backup/ddbb.sql
/usr/bin/mysqldump --user=[USUARIO] --password=[PASSWORD] [BASE_DE_DATOS] > /mariadb-backup/ddbb.sql
--- Esto vuelca a fichero comprimido .gz
/usr/bin/mysqldump --user=[USUARIO] --password=[PASSWORD] [BASE_DE_DATOS] | gzip -c > /mariadb-backup/ddbb.sql.gz
--- Si queremos monitorear el ratio (tiene que estar instalado el paquete pv):
/usr/bin/mysqldump --user=[USUARIO] --password=[PASSWORD] [BASE_DE_DATOS] | pv | gzip -c > /mariadb-backup/ddbb.sql.gz
===== COSAS VARIADAS DE ADMINISTRACION =========================================================================================
mysql -u root
CREATE DATABASE IF NOT EXISTS testdb /*DEFAULT CHARACTER SET utf8mb4*/;
DROP DATABASE testdb;
SHOW databases;
SELECT default_character_set_name FROM information_schema.SCHEMATA WHERE schema_name = "testdb";
CREATE USER 'userdb'@'localhost' IDENTIFIED BY 'password';
UPDATE mysql.user SET Password=PASSWORD('new_password') WHERE USER='user' AND Host="host";
UPDATE mysql.user SET Password='cadena_larga_como_la_que_se_ve_en_el_select_de_abajo' WHERE USER='user' AND Host="host";
SELECT user,password,host FROM mysql.user;
SHOW GRANTS FOR 'Usuario'@'localhost';
SHOW processlist;
SHOW status like 'Threads%';
Threads_cached. Es el número de procesos cacheados actualmente.
Threads_connected. Número de conexiones activas actualmente.
Threads_create. Las conexiones que se han creado hasta el momento.
Threads_running. Las que se están ejecutando actualmente.

34
BBDD/Desbloquear usuario ORACLE.txt Normal file
View File

@ -0,0 +1,34 @@
Por defecto, en ORACLE 11g, si los usuarios se crean bajo el ROLE Default, estarán sujetos a una política en la cual la contraseña caducará a los 180 días.
Esto es bueno puesto que te obliga a cambiar la contraseña. El problema es cuando uno desconoce esta política o se le olvida cambiar la contraseña en ese tiempo y el usuario, pasado ese periodo, se bloquea con sus correspondientes consecuencias para la aplicación que lo usa.
Para poder ver si en nuestra base de datos tenemos activa esta política ejecutamos la siguiente consulta:
SQL> select * from dba_profiles;
El resultado que obtenemos en este caso el siguiente:
DEFAULT;COMPOSITE_LIMIT;KERNEL;UNLIMITED
DEFAULT;SESSIONS_PER_USER;KERNEL;UNLIMITED
DEFAULT;CPU_PER_SESSION;KERNEL;UNLIMITED
DEFAULT;CPU_PER_CALL;KERNEL;UNLIMITED
DEFAULT;LOGICAL_READS_PER_SESSION;KERNEL;UNLIMITED
DEFAULT;LOGICAL_READS_PER_CALL;KERNEL;UNLIMITED
DEFAULT;IDLE_TIME;KERNEL;UNLIMITED
DEFAULT;CONNECT_TIME;KERNEL;UNLIMITED
DEFAULT;PRIVATE_SGA;KERNEL;UNLIMITED
DEFAULT;FAILED_LOGIN_ATTEMPTS;PASSWORD;10
DEFAULT;PASSWORD_LIFE_TIME;PASSWORD;180
DEFAULT;PASSWORD_REUSE_TIME;PASSWORD;UNLIMITED
DEFAULT;PASSWORD_REUSE_MAX;PASSWORD;UNLIMITED
DEFAULT;PASSWORD_VERIFY_FUNCTION;PASSWORD;NULL
DEFAULT;PASSWORD_LOCK_TIME;PASSWORD;1
DEFAULT;PASSWORD_GRACE_TIME;PASSWORD;7
Como podemos observa vemos que para el ROLE Defaut la política de expiración de password está puesta a 180 días. Si nuestros usuarios tienen este ROLE asociado, están sujetos a esta política.
Si queremos verificar a qué profile está asociado nuestro usuario, lo podemos hacer con la siguiente consulta:
select username ,profile from dba_users;
Para cambiar esta política en el ROLE DEFAULT y establecerla a indefinida permitiéndonos así a nosotros cambiar la contraseña del usuario cuando creamos conveniente ejecutaremos la siguiente consulta:
ALTER PROFILE DEFAULT LIMIT PASSWORD_LIFE_TIME UNLIMITED;
En caso de que nuestro usuario haya sido bloqueado debido a que ya pasaron los 180 días desde su creación o cambio de contraseña, podremos desbloquearlo y cambiar la contraseña de la siguiente forma
SQL> alter user usuario identified by "password";
SQL> alter user usuario account unlock;

14
BBDD/Limitar acceso a tablas mysql por usuario y maquina.txt Normal file
View File

@ -0,0 +1,14 @@
# Maquina suele ser localhost
GRANT SELECT, INSERT, UPDATE, DELETE ON 'base_datos'.'tabla' TO 'user'@'maquina';
# Repite el codigo cambiando las tablas para darle acceso a multiples tablas.
GRANT SELECT, INSERT, UPDATE, DELETE ON 'base_datos'.'tabla2' TO 'user'@'maquina';
GRANT SELECT, INSERT, UPDATE, DELETE ON 'base_datos'.'tabla3' TO 'user'@'maquina';
# Conceder privilegios a unos pocos campos
GRANT SELECT(campo1, campo2, campo3), INSERT(campo1, campo2, campo3), UPDATE(campo1, campo2, campo3), DELETE ON 'base_datos'.'tabla4' TO 'user'@'maquina';
# Si te aparece un error 1142 puede ser porque tengas tablas relacionadas a las que no le hayas dado privilegios.
# Eliminar privilegios en una tabla
REVOKE ALL PRIVILEGES ON 'base_datos'.'tabla' FROM 'user'@'maquina';

14
BBDD/Obtener los permisos de una tabla de una bbdd sql server.txt Normal file
View File

@ -0,0 +1,14 @@
SACAR LOS PERMISOS DE TABLAS EN BBDD:
USE LA_BBDD_DESEADA
SELECT pr.principal_id, pr.name, pr.type_desc,
pr.authentication_type_desc, pe.state_desc,
pe.permission_name, s.name + '.' + o.name AS ObjectName
FROM sys.database_principals AS pr
JOIN sys.database_permissions AS pe
ON pe.grantee_principal_id = pr.principal_id
JOIN sys.objects AS o
ON pe.major_id = o.object_id
JOIN sys.schemas AS s
ON o.schema_id = s.schema_id
WHERE o.name like 'AQUI_LA_TABLA'

30
BBDD/Recuperar contraseña root de MYSQL.txt Normal file
View File

@ -0,0 +1,30 @@
Detener el servicio de MySQL. Esto lo puedes hacer con uno de los siguientes comandos:
service mysqld stop
o bien:
/etc/init.d/mysqld stop
Iniciar el servicio de MySQL en modo abierto con el siguiente comando:
mysqld_safe --skip-grant-tables --skip-networking&
Este comando, con la opción –skip-grant-tables, iniciará MySQL sin emplear el sistema de privilegios, por lo que tendrás acceso ilimitado a todas las bases de datos.
La opción –skip-networking hará que se dejen de escuchar conexiones TCP/IP externas, lo que evitará problemas externos durante el cambio.
Una vez iniciado MySQL, deberás acceder con el usuario “root”. Para ello puedes hacerlo simplemente con:
mysql -u root
Una vez dentro de MySQL, tendrás que acceder a la base de datos MySQL, que es donde tendrás que realizar el cambio de la contraseña
mysql> use mysql;
Dentro de la base de datos MySQL, podrás lanzar la siguiente query que realizará el cambio de contraseña:
mysql> UPDATE user SET password=PASSWORD('contraseña') WHERE user='root';
Recuerda que tendrás que cambiar contraseña por la nueva contraseña que quieras configurar.
Y cuando termine podrás salir del servidor MySQL con:
mysql> exit
Finalmente tendrás reiniciar el servicio de MySQL para que inicie en modo normal:
service mysqld restart
o bien:
/etc/init.d/mysqld restart
Una vez realizados los pasos anteriores, ya habrás modificado la contraseña del usuario “root” de MySQL. El comando para realizar el cambio de contraseña se puede emplear para los usuarios que quieras, sin embargo es necesario iniciar MySQL sin el sistema de privilegios para realizar el cambio del usuario “root” si has perdido tu contraseña.

7
BBDD/SQL Server - Detener trabajo.sql Normal file
View File

@ -0,0 +1,7 @@
Detener trabajo SQL
En SQL Server Management Studio ejecutar el comando:
EXEC msdb.dbo.sp_stop_job @job_name = 'nombre de proceso';
Por ejemplo, para detener el proceso de carga de mercancias:
EXEC msdb.dbo.sp_stop_job @job_name = 'ProcesoBDCargaMercancias';

262
BBDD/SQL Server sentencias para ver problemas.txt Normal file
View File

@ -0,0 +1,262 @@
-- Proporciona información acerca de los usuarios actuales, sesiones y procesos en una instancia de SQL Server.
USE [master]
GO
exec sp_who; -- sp_who2 da más datos. ;-- sp_who [ [ @loginame = ] 'login' | session ID | 'ACTIVE' ]
-- MUESTRA CONEXIONES ACTIVAS
SELECT @@ServerName AS server,
NAME AS dbname,
LOGINAME AS LoginName,
PROGRAM_NAME as Aplicacion,
COUNT(STATUS) AS number_of_connections,
GETDATE() AS timestamp
FROM sys.databases sd
LEFT JOIN sys.sysprocesses sp ON sd.database_id = sp.dbid
WHERE database_id NOT BETWEEN 1 AND 4
AND LOGINAME IS NOT NULL
GROUP BY NAME,LOGINAME,PROGRAM_NAME;
-- MUESTRA TRANSACIONES ABIERTAS SIN FINALIZAR (POR EJEMPLO ROLLBACKS PERPETUOS)
dbcc opentran
-- MUESTRA BLOQUEOS Y A CONTINUACION LOS PROCESOS EXISTENTES
USE [master]
GO
SELECT session_id,blocking_session_id,wait_time,wait_type,last_wait_type,wait_resource,transaction_isolation_level,lock_timeout
FROM sys.dm_exec_requests
WHERE blocking_session_id <> 0
GO
SELECT spid,status,loginame,hostname,blk = CONVERT(char(3), blocked),dbname=SUBSTRING(DB_NAME(dbid),1, 10),cmd,waittype
FROM master.dbo.sysprocesses
WHERE spid IN (SELECT blocked FROM master.dbo.sysprocesses)
GO
exec sp_who2
GO
-- INFORMACION DE BLOQUEOS Y BLOQUEANTES CON INFORMACION EXTENDIDA
WITH cteHead ( session_id,request_id,wait_type,wait_resource,last_wait_type,is_user_process,request_cpu_time
,request_logical_reads,request_reads,request_writes,wait_time,blocking_session_id,memory_usage
,session_cpu_time,session_reads,session_writes,session_logical_reads
,percent_complete,est_completion_time,request_start_time,request_status,command
,plan_handle,sql_handle,statement_start_offset,statement_end_offset,most_recent_sql_handle
,session_status,group_id,query_hash,query_plan_hash)
AS ( SELECT sess.session_id, req.request_id, LEFT (ISNULL (req.wait_type, ''), 50) AS 'wait_type'
, LEFT (ISNULL (req.wait_resource, ''), 40) AS 'wait_resource', LEFT (req.last_wait_type, 50) AS 'last_wait_type'
, sess.is_user_process, req.cpu_time AS 'request_cpu_time', req.logical_reads AS 'request_logical_reads'
, req.reads AS 'request_reads', req.writes AS 'request_writes', req.wait_time, req.blocking_session_id,sess.memory_usage
, sess.cpu_time AS 'session_cpu_time', sess.reads AS 'session_reads', sess.writes AS 'session_writes', sess.logical_reads AS 'session_logical_reads'
, CONVERT (decimal(5,2), req.percent_complete) AS 'percent_complete', req.estimated_completion_time AS 'est_completion_time'
, req.start_time AS 'request_start_time', LEFT (req.status, 15) AS 'request_status', req.command
, req.plan_handle, req.[sql_handle], req.statement_start_offset, req.statement_end_offset, conn.most_recent_sql_handle
, LEFT (sess.status, 15) AS 'session_status', sess.group_id, req.query_hash, req.query_plan_hash
FROM sys.dm_exec_sessions AS sess
LEFT OUTER JOIN sys.dm_exec_requests AS req ON sess.session_id = req.session_id
LEFT OUTER JOIN sys.dm_exec_connections AS conn on conn.session_id = sess.session_id
)
, cteBlockingHierarchy (head_blocker_session_id, session_id, blocking_session_id, wait_type, wait_duration_ms,
wait_resource, statement_start_offset, statement_end_offset, plan_handle, sql_handle, most_recent_sql_handle, [Level])
AS ( SELECT head.session_id AS head_blocker_session_id, head.session_id AS session_id, head.blocking_session_id
, head.wait_type, head.wait_time, head.wait_resource, head.statement_start_offset, head.statement_end_offset
, head.plan_handle, head.sql_handle, head.most_recent_sql_handle, 0 AS [Level]
FROM cteHead AS head
WHERE (head.blocking_session_id IS NULL OR head.blocking_session_id = 0)
AND head.session_id IN (SELECT DISTINCT blocking_session_id FROM cteHead WHERE blocking_session_id != 0)
UNION ALL
SELECT h.head_blocker_session_id, blocked.session_id, blocked.blocking_session_id, blocked.wait_type,
blocked.wait_time, blocked.wait_resource, h.statement_start_offset, h.statement_end_offset,
h.plan_handle, h.sql_handle, h.most_recent_sql_handle, [Level] + 1
FROM cteHead AS blocked
INNER JOIN cteBlockingHierarchy AS h ON h.session_id = blocked.blocking_session_id and h.session_id!=blocked.session_id --avoid infinite recursion for latch type of blocking
WHERE h.wait_type COLLATE Latin1_General_BIN NOT IN ('EXCHANGE', 'CXPACKET') or h.wait_type is null
)
SELECT bh.*, txt.text AS blocker_query_or_most_recent_query
FROM cteBlockingHierarchy AS bh
OUTER APPLY sys.dm_exec_sql_text (ISNULL ([sql_handle], most_recent_sql_handle)) AS txt;
-- CAPTURAR TRANSACCIONES DE LARGA DURACION O NO CONFIRMADAS
SELECT [s_tst].[session_id],
[database_name] = DB_NAME (s_tdt.database_id),
[s_tdt].[database_transaction_begin_time],
[sql_text] = [s_est].[text]
FROM sys.dm_tran_database_transactions [s_tdt]
INNER JOIN sys.dm_tran_session_transactions [s_tst] ON [s_tst].[transaction_id] = [s_tdt].[transaction_id]
INNER JOIN sys.dm_exec_connections [s_ec] ON [s_ec].[session_id] = [s_tst].[session_id]
CROSS APPLY sys.dm_exec_sql_text ([s_ec].[most_recent_sql_handle]) AS [s_est];
-- Para terminar la sesión que bloquea, ID 74 por ejemplo, usamos el comando KILL.
KILL 74
GO
-- MUESTRA PROCESOS ORDENADOS POR CONSUMO DE CPU
SELECT TOP 10
qs.total_worker_time/qs.execution_count as [Avg CPU Time],
SUBSTRING(qt.text,qs.statement_start_offset/2,
(case when qs.statement_end_offset = -1
then len(convert(nvarchar(max), qt.text)) * 2
else qs.statement_end_offset end -qs.statement_start_offset)/2)
as query_text,
qt.dbid, dbname=db_name(qt.dbid),
qt.objectid
FROM sys.dm_exec_query_stats qs
cross apply sys.dm_exec_sql_text(qs.sql_handle) as qt
ORDER BY [Avg CPU Time] DESC
-- QUERYS CON MAYOR CONSUMO
SELECT TOP 10 SUBSTRING(qt.TEXT, (qs.statement_start_offset/2)+1,
((CASE qs.statement_end_offset
WHEN -1 THEN DATALENGTH(qt.TEXT)
ELSE qs.statement_end_offset
END - qs.statement_start_offset)/2)+1),
qs.execution_count,
qs.total_logical_reads, qs.last_logical_reads,
qs.total_logical_writes, qs.last_logical_writes,
qs.total_worker_time,
qs.last_worker_time,
qs.total_elapsed_time/1000000 total_elapsed_time_in_S,
qs.last_elapsed_time/1000000 last_elapsed_time_in_S,
qs.last_execution_time,
qp.query_plan
FROM sys.dm_exec_query_stats qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) qt
CROSS APPLY sys.dm_exec_query_plan(qs.plan_handle) qp
ORDER BY qs.total_worker_time DESC -- CPU time
-- PROCESOS MAS COSTOSOS
SELECT TOP 5
qs.total_worker_time AS [Total CPU Time],
qs.execution_count AS [Ejecuciones],
qs.total_worker_time/qs.execution_count as [Tiempo Medio CPU],
SUBSTRING(qt.text,qs.statement_start_offset/2,
(case when qs.statement_end_offset = -1 then len(convert(nvarchar(max), qt.text)) * 2
else qs.statement_end_offset end -qs.statement_start_offset)/2) AS sentencia
FROM
sys.dm_exec_query_stats qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) as qt
ORDER BY [Tiempo Medio CPU] DESC
-- ESTADISTICAS DE SERVIDOR
SELECT * FROM sys.dm_os_performance_counters
WHERE object_name LIKE '%General Statistics%';
-- MUESTRA CONTADORES DE EJECUCION
USE [master]
GO
SELECT TOP 10
qs.execution_count,
SUBSTRING(qt.text,qs.statement_start_offset/2,
(case when qs.statement_end_offset = -1
then len(convert(nvarchar(max), qt.text)) * 2
else qs.statement_end_offset end -qs.statement_start_offset)/2)
as query_text,
qt.dbid, dbname=db_name(qt.dbid),
qt.objectid
FROM sys.dm_exec_query_stats qs
cross apply sys.dm_exec_sql_text(qs.sql_handle) as qt
ORDER BY
qs.execution_count DESC
-- MUESTRA TODOS LOS TRABAJOS EXISTENTES EN EL SERVIDOR
USE msdb;
GO
EXEC dbo.sp_help_jobactivity;
GO
-- MUESTRA TODOS LOS TRABAJOS EJECUTADOS, CUANDO Y CUANTO DURARON
SET NOCOUNT ON;
SELECT sj.name,
sh.run_date,
sh.step_name,
STUFF(STUFF(RIGHT(REPLICATE('0', 6) + CAST(sh.run_time as varchar(6)), 6), 3, 0, ':'), 6, 0, ':') 'run_time',
STUFF(STUFF(STUFF(RIGHT(REPLICATE('0', 8) + CAST(sh.run_duration as varchar(8)), 8), 3, 0, ':'), 6, 0, ':'), 9, 0, ':') 'run_duration (DD:HH:MM:SS) '
FROM msdb.dbo.sysjobs sj
JOIN msdb.dbo.sysjobhistory sh
ON sj.job_id = sh.job_id
-- MUESTRA LOS TRABAJOS EN EJECUCION
SELECT
ja.job_id,
j.name AS job_name,
ja.start_execution_date,
ISNULL(last_executed_step_id,0)+1 AS current_executed_step_id,
Js.step_name
FROM msdb.dbo.sysjobactivity ja
LEFT JOIN msdb.dbo.sysjobhistory jh
ON ja.job_history_id = jh.instance_id
JOIN msdb.dbo.sysjobs j
ON ja.job_id = j.job_id
JOIN msdb.dbo.sysjobsteps js
ON ja.job_id = js.job_id
AND ISNULL(ja.last_executed_step_id,0)+1 = js.step_id
WHERE ja.session_id = (SELECT TOP 1 session_id FROM msdb.dbo.syssessions ORDER BY agent_start_date DESC)
AND start_execution_date is not null
AND stop_execution_date is null
ORDER BY Js.step_name
-- MUESTRA LAS ESPERAS EXISTENTES
SELECT TOP 10
[Wait type] = wait_type,
[Wait time (s)] = wait_time_ms / 1000,
[% waiting] = CONVERT(DECIMAL(12,2), wait_time_ms * 100.0
/ SUM(wait_time_ms) OVER())
FROM sys.dm_os_wait_stats
WHERE wait_type NOT LIKE '%SLEEP%'
ORDER BY wait_time_ms DESC;
********************************************************************************
'CLR_SEMAPHORE'.- Tiene lugar cuando una tarea está realizando actualmente la ejecución de CLR y espera un semáforo.
'LAZYWRITER_SLEEP'.- Tiene lugar cuando se suspenden tareas de escritura diferida. Ésta es una medida del tiempo invertido por las tareas en segundo plano que esperan.
'RESOURCE_QUEUE'.- Tiene lugar durante la sincronización de diferentes colas internas de recursos.
'SLEEP_TASK'.- Tiene lugar cuando una tarea se mantiene inactiva mientras espera que se produzca un evento genérico.
'SLEEP_SYSTEMTASK'.- Tiene lugar durante el inicio de una tarea en segundo plano mientras se espera que tempdb finalice el inicio.
'SQLTRACE_BUFFER_FLUSH'.- Tiene lugar cuando una tarea está esperando a que una tarea en segundo plano vuelque los búferes de seguimiento al disco cada cuatro segundos.
'WAITFOR'.- Tiene lugar como resultado de una instrucción WAITFOR de Transact-SQL. La duración de la espera viene determinada por los parámetros de la instrucción. Se trata de una espera iniciada por el usuario.
'CLR_AUTO_EVENT'.- Tiene lugar cuando una tarea está realizando actualmente la ejecución de Common Language Runtime (CLR) y espera que se inicie un evento automático determinado. Son habituales las esperas largas y no indican ningún problema.
'CLR_MANUAL_EVENT'.- Tiene lugar cuando una tarea está realizando actualmente la ejecución de CLR y espera que se inicie un evento manual específico.
********************************************************************************
-- MUESTRA CUANTAS PAGINAS USADAS HAY POR MEMORY BOOFER POOL
SELECT (CASE
WHEN ( [database_id] = 32767 ) THEN 'Resource Database'
ELSE Db_name (database_id)
END ) AS 'Database Name',
Sum(CASE
WHEN ( [is_modified] = 1 ) THEN 0
ELSE 1
END) AS 'Clean Page Count',
Sum(CASE
WHEN ( [is_modified] = 1 ) THEN 1
ELSE 0
END) AS 'Dirty Page Count'
FROM sys.dm_os_buffer_descriptors
GROUP BY database_id
ORDER BY DB_NAME(database_id);
-- VACIA MEMORY BUFFER POOL
DBCC DROPCLEANBUFFERS
-- DISMINUIR TEMP-DB
>Primero comprobar cuanto espacio está ocupado
use tempdb;
exec sp_spaceused
>Dependiendo del espacio ocupado disminuir la bbdd en porcentaje (ej. 10%)
dbcc shrinkdatabase (tempdb, 10);

3
BBDD/SQL Server ver ejecucion actual lanzada.txt Normal file
View File

@ -0,0 +1,3 @@
select * from job_jobrun
select * from job_steprun
select * from job_steperror

34
BBDD/backup bbdd postgresql a directorio con retencion de 30 dias.txt Normal file
View File

@ -0,0 +1,34 @@
Este script realiza el backup de bases de datos postgresql a un directorio determinado y mantiene las copias durante 30 dias.
El contenido del script es el siguiente
#!/bin/bash
Tarea de Backup Bases de datos POSTGRESQL.*
backup_dir="/var/data/backup/"
#Añadimos la fecha de backup al nuevo archivo
backup_fecha=`date +%d-%m-%Y_%H-:%M`
#Número de días que vamos a mantener nuestros backups
numero_dias="30"
#Creamos lista de bases de datos para realizar backup
bases_de_datos=`sudo -u postgres /usr/bin/psql -l -t | cut -d'|' -f1 | sed -e 's/ //g' -e '/^$/d'`
#Comenzamos tarea de backup
#El nombre del fichero de backup dera: nombre de la base de datos + fecha + estensión .gz
for i in $bases_de_datos; do
if [ "$i" != "template0" ] && [ "$i" != "template1" ]; then
echo Volcamos $i a $backup_dir$i_$backup_fecha
sudo -u postgres /usr/bin/pg_dump -Fc $i|gzip > $backup_dir$i_$backup_fecha.gz
sudo chown postgres:postgres $backup_dir$i_$backup_fecha.gz
sudo chmod 700 $backup_dir$i_$backup_fecha.gz
fi
done
#Realizamos tareas de limpieza
sudo find $backup_dir -type f -prune -mtime +$numero_dias -exec rm -f {} \;

28
BBDD/create a read-only user in PostgreSQL.txt Normal file
View File

@ -0,0 +1,28 @@
Create a read-only user in PostgreSQL
1. To create a new user in PostgreSQL:
CREATE USER username WITH PASSWORD 'your_password';
2. GRANT the CONNECT access:
GRANT CONNECT ON DATABASE database_name TO username;
3. Then GRANT USAGE on schema:
GRANT USAGE ON SCHEMA schema_name TO username;
4. GRANT SELECT
Grant SELECT for a specific table:
GRANT SELECT ON table_name TO username;
Grant SELECT for multiple tables:
GRANT SELECT ON ALL TABLES IN SCHEMA schema_name TO username;
*If you want to grant access to the new table in the future automatically, you have to alter default:
ALTER DEFAULT PRIVILEGES IN SCHEMA schema_name
GRANT SELECT ON TABLES TO username;
ejemplo:
CREATE USER usuario WITH PASSWORD 'Password';
GRANT CONNECT ON DATABASE openproject TO usuario;
GRANT USAGE ON SCHEMA public TO usuario;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO usuario;

45
BBDD/migrar mysql a mariadb.txt Normal file
View File

@ -0,0 +1,45 @@
#REALIZADA COPIA DE LA BB.DD. (ejemplo Wordpress)
mysqldump --user=root --password Wordpress > /home/.../Wordpress.sql
#PARAMOS SERVICIO ANTES DE REALIZAR LA DESINSTALACIÓN DE MYSQL
sudo systemctl stop mysql
#REALIZAMOS COPIA DEL ARCHIVO DE CONFIGURACIÓN DE SNMP YA QUE ESTE SE DESINSTALA JUNTO CON PAQUETE MYSQL
sudo cp -p /etc/snmp/snmpd.conf /etc/snmp/snmpd.conf.bck
#DESINSTALAMOS MYSQL
sudo apt-get purge mysql*
sudo apt-get autoremove
sudo apt-get autoclean
sudo rm -rf /var/lib/mysql
#INSTALAMOS MARIADB
sudo apt-key adv --fetch-keys 'https://mariadb.org/mariadb_release_signing_key.asc'
sudo add-apt-repository 'deb [arch=amd64] http://mariadb.mirror.globo.tech/repo/10.5/ubuntu focal main'
sudo apt-get update
sudo apt-get install mariadb-server mariadb-client
sudo mysql_secure_installation
sudo systemctl enable mariadb
#RECREAMOS NUESTRA BASE DE DATOS (aqui en los grant se usa el usuario root, pero podría ser otro usuario de bbdd)
mariadb -u root -p
CREATE DATABASE Wordpress;
GRANT USAGE ON Wordpress. TO 'root'@localhost IDENTIFIED BY 'xxxxxxxxxxxxxxxxx';*
GRANT ALL ON `Wordpress`. TO 'root'@localhost;flush privileges;*
exit
#VOLVEMOS A RESTAURAR NUESTRA BASE DE DATOS
mariadb -u root -p Wordpress < /home/.../Wordpress.sql
#REINICIAMOS SERVICIOS MARIADB
sudo systemctl stop mariadb
sudo systemctl start mariadb
sudo systemctl status mariadb
#REINSTALAMOS EL SERVICIO SNMPD
sudo apt install -y snmpd
mv /etc/snmp/snmpd.conf.bck /etc/snmp/snmpd.conf
sudo systemctl enable snmpd
sudo systemctl restart snmpd
sudo systemctl status snmpd

2
BBDD/mysql poner password a root.txt Normal file
View File

@ -0,0 +1,2 @@
$mysql
grant all privileges on *.* to root@'localhost' identified by 'sesamo' with grant option;

24
Comprobar SSL-TLS en servidores de correo (SMTP IMAP POP3) y SPF.txt Normal file
View File

@ -0,0 +1,24 @@
Comprobar SSL/TLS en servidores de correo (SMTP IMAP POP)
Ahora con la importancia de tener conexiones seguras, muchos han decidido cambiar y usar protocolos SSL o TLS en su servidor de correo y otros se han visto obligados ya que hay cliente de correo que sólo soportan ese tipo de conexiones.
Para conectar con un servicio que no tiene SSL/TLS podemos usar telnet:
IMAP: telnet mail.dominios.es 143
POP3: telnet mail.dominio.es 110SMTP: telnet mail.dominio.es 25
Con eso podremos comprobar que la conexión al servidor se realiza sin problemas, e incluso podemos llegar a mandar correos y consultarlos.
Cuando tenemos un servicio bajo SSL/TLS, el telnet no será capaz de conectar por lo que tendremos que usar el cliente de openssl. En la mayor parde de distros de linux debería estar instalado, si no, con una búsqueda rápida en los repositorios lo encontrarás.
Para comprobar que funciona, y además mostrar el certificado (para comprobar si es válido o autofirmado):
SSL
IMAP: openssl s_client -showcerts -connect mail.dominios.es:995
POP3: openssl s_client -showcerts -connect mail.dominios.es:993
SMTP: openssl s_client -showcerts -connect mail.dominios.es:465
TLS
IMAP: openssl s_client -showcerts -connect mail.dominios.es:143 -starttls imap
POP: openssl s_client -showcerts -connect mail.dominios.es:110 -starttls pop3
SMTP: openssl s_client -showcerts -connect mail.dominios.es:25 -starttls smtp
Con eso podremos conectar y revisar que todo vaya bien.
Comprobación del registro SPF:
spfquery -sender=<mail del dominio> -ip=<ip servidor correo> -helo=<nombre host>

4
Convertir VMDK a OVF.txt Normal file
View File

@ -0,0 +1,4 @@
Hay que utilizar ovftool
C:\Program Files (x86)\VMware\VMware Player\OVFTool
ovftool maquina.vmx maquina.ovf

4
Crear y Activar Disco Red para TimeMachine.txt Normal file
View File

@ -0,0 +1,4 @@
# Primero creamos un disco de 250gb para usar con la TimeMachine
hdiutil create -size 250g -type SPARSEBUNDLE -fs "HFS+J" TimeMachine.sparsebundle
# Una vez creado lo movemos a la unidad de red que deseemos y tras montarlo lo activamos
sudo tmutil setdestination /Volumes/TimeMachine

38
Enviar un correo por telnet.txt Normal file
View File

@ -0,0 +1,38 @@
Primero nos conectamos al servidor SMTP remoto por telnet en el puerto 25:
$telnet servidor_remoto 25
Recibiremos un mensaje similar al que sigue:
Trying 200.40.31.8…
Connected to servidor_remoto.
Escape character is ‘^]’.
220 servidor_remoto ESMTP
Luego debemos saludar al servidor con HELO o EHLO:
helo servidor_remoto
250 mta01.servidor_remoto
con el comando MAIL FROM indicamos la dirección de correo de quien envía:
MAIL FROM: enrique@servidor_remoto
250 2.1.0 Ok
Luego indicaremos el destinatario del email con RCPT TO (si hay varios destinatarios se pondrán varios RCPT TO):
RCPT TO:usuario@dominio.dom
250 Accepted
Con el comando DATA comenzamos a armar nuestro correo:
DATA
354 Enter message, ending with «.» on a line by itself
Aquí debemos tomar en cuenta que las primeras líneas que debemos mandar son los encabezados que serán visibles para el usuario, como From>
From:'Juan Perez'<juan_perez@dominio.com>
To:'Usuario1'<usuario1@dominio.dom>
Cc:'Usuario2'<usuario2@dominio.dom>
Cc:'Usuario3'<usuario3@dominio.dom>
Subject: Hola este es un correo de prueba
Aqui escribo el cuerpo del email y cuando termino – en una linea en blando – digito un punto «.»
.
250 OK id=1bhdeY-0000Vb-FO
Listo! El correo ha sido enviado

33
Generar certificados autofirmados con OpenSSL.txt Normal file
View File

@ -0,0 +1,33 @@
Generar certificados autofirmados con OpenSSL
Crear un certificado raíz auto-firmado
Para crear un certificado primero hay que generar una clave privada, luego hay que añadir los datos personales y finalmente hay que firmarlo. Utilizar los siguientes comandos para generar un certificado auto-firmado:
• Genera una clave privada de longitud 2048
openssl genrsa -out clave_raiz.pem 2048
• Generar un certificado auto-firmado a partir de la clave anterior. Cuando pregunte los datos personales del certificado, especificar en el nombre que es el certificado RAIZ.
openssl req -new -x509 -key clave_raiz.pem -out raiz.cer -days 730 –config openssl.cfg
• Verificar el contenido del certificado. Comprobado que el subject y el issuer son iguales.
openssl x509 -in raiz.cer -text
Crear un certificado personal (CSR)
Para crear un certificado personal, debemos crear una clave privada, luego generar un Certificate Signing Request, y finalmente debemos conseguir la firma de una CA:
• Genera una clave privada de longitud 2048:
openssl genrsa -out mi_clave_privada.pem 2048
• Generar un certifícate signing request, utilizando ahora el nombre personal
openssl req -new -key mi_clave_privada.pem -out micert.csr –config openssl.cfg
Firmar el certificado personal con el certificado raiz
Para obtener un certificado "valido" lo vamos a firmar con nuestro propio certificado raíz que hemos generando antes. No es una CA de reconocido prestigio, pero es la nuestra.
• Firmamos el CSR utilizando nuestra clave raíz:
openssl x509 -req -in micert.csr -CA raiz.cer -CAkey clave_raiz.pem -set_serial 12345 -days 365 -out micert.pem
• Verificamos el contenido del certificado. En este caso comprobad que el subject y el issuer son iguales:
openssl x509 -in micert.pem -text
Guardar el certificado personal en formato PKCS#12
Para guardar nuestro certificado personal de forma segura, debemos juntar la parte pública del certificado (micert.pem) con la clave privada (mi_clave_privada.pem) en un archivo seguro .p12 protegido por contraseña.
openssl pkcs12 -export -in micert.pem -inkey mi_clave_privada.pem -out micert.p12

116
Google Hacking.txt Normal file
View File

@ -0,0 +1,116 @@
Google Hacking es el significado del uso original del motor de búsqueda Google para buscar tecnología de la información y comportamiento, ahora se refiere al uso de varios motores de búsqueda para buscar tecnología de la información y comportamiento. Google Hacking no es realmente nada nuevo, de hecho hace años que he visto en algunos sitios extranjeros relacionados con la introducción, pero debido a que en ese momento no le daba importancia a esta tecnología, eso solo se usa para encontrar el mdb sin nombre u otros que abandonaron la WebShell o algo, no demasiado uso práctico. .Pero hace algún tiempo mordisqueó cuidadosamente cierta información para encontrar repentinamente Google Hacking no es tan simple.
=================
intext
Texto contenido en una pagina web, con esta clave le indicamos al motor de Google que nos retorne el texto relaciónado a nuestro criterio de búsqueda.
Ejemplo
intext: Mobility
=================
intitle
Nos devuelve todo el titulo de la pagina que contenga nuestra cadena.
Ejemplo
intitle:Safety Angel
=================
cache
Buscar información en la cache de google, algunas veces es posible encontrar información relevante.
=================
define
Esta nos permite definir lo que buscamos.
Ejemplo:
define: backtrackacademy
=================
filetype
Recomiendo esto para ya sea en ataques de red o detrás de nosotros, para decir que la recopilación de información sobre objetivos específicos, se necesita utilizar este tipo de búsqueda para el archivo de entrada especificado, por ejemplo: filetype:. doc devolverá toda la URL del archivo final del documento. por supuesto, si encuentra .bak, .mdb o .inc también es posible, la información obtenida puede ser más rica
=================
info
Encontrar información basica sobre un sitio en especifico.
=================
inurl
Se buscan caracteres existentes dentro de la URL del sitio.
Ejemplo
inurl: admin
allinurl con similar a inurl
=================
site
Este es un comando util para encontrar información como por ejemplo: site: kali-linux.co y nos retorna todas las URL.
=================
=================
Expresiones comunes
[all]inurl
[all]intext
[all]intitle
site
ext,filetype
Simbolos: – . * |
Expresiones booleanas: and or not
=================
=================
Privacidad de la información
1) Usuario y contraseña
“create table” insert into” “pass|passwd|password” (ext:sql | ext:dump | ext:txt)
“your password * is” (ext:csv | ext.doc | ext:txt)
2) Llave
“index of” slave_datatrans OR from_master
3) Contraseña de privacidad
“Begin (DSA | RSA)” ext:key
“index of” “secreting.gpg”
4) Mensajes cifrados
-“public | pubring | pubkeysignature | pgp | and | or |release” ext:gpg
-intext:”and” (ext:enc | ext:axx)
“ciphervalue” ext:xml
5) Logs en los chats
“session start” “session ident” thomas ext:txt
6) Emails
“index of” inbox.dbx
“To parent directory” inurl:”Identities”
7) Archivos confidenciales y directorios
“index of” (private | secure | geheim | gizli)
“robots.txt” “User-agent” ext:txt
“this document is private | confidential | secret” ext:doc | ext:pdf | ext:xls
intitle:”index of” “jpg | png | bmp” inurl”personal | inurl:private
8) Webcams
intitle:”live View/ -AXIS” | inurl:view/view.shtml
inurl:”ViewFrame?Mode=”
inurl:”MultiCameraFrame?Mode=”
inturl:”axis-cgi/mjpg”
intext:”MOBOTIX M1″
intext:”Open Menu”
inurl:”view/index.shtml”
9) Información privada de información
allintext: name email phone address intext:”thomas fischer” ext:pdf
Twiki inurl:”View/Main” “thomas fischer”
intitle:CV OR intitle:Lebenslauf “thomas fischer”
intitle:CV OR intitle:Lebenslauf ext:pdf OR ext:doc
10) Nombres de usuario
ntitle:”usage Statistics for” intext:”Total Unique Usernames”
11) Procedimientos poco confiables para divulgar información
“php version” intitle:phpinfo inurl:info.php
12) Vulnerabilidades de inyección SQL y camino de apertura débil
“advanced guestbook * powered” inurl:addentry.php
intitle:”View img” inurl:viewimg.php
13) Reportes de escaneo de vulnerabilidades
“Assessment report” “nessus” filetype:pdf
14) Bases de datos del programa y logs del servidor
“Welcome to phpmyadmin ***” “running on * as root@*” intitle:phpmyadmin
“mysql error with query”
15) Registros del robots.txt
“robots.txt” “disallow:” filetype:txt
16) Información de VNC
“vnc desktop” inurl:5800
17) Verificar por impresoras conectadas en redes publicas
nurl:”port_255″ -htm

43
Instalar Kali Linux con interfaz gráfica en Windows 10.txt Normal file
View File

@ -0,0 +1,43 @@
Kali Linux es de los más nombrados y usados a nivel mundial en temas de seguridad tanto a nivel usuario como empresarial. Desde Microsoft han sido inteligentes y nos han dado la facilidad de su integración desde sistemas Windows.
Kali Linux es una distribución muy popular para realizar Pentesting, desde marzo del 2018 esta disponible en Windows 10 desde la Microsoft Store. Con este tutorial aprenderemos a instalarlo y activaremos la interfaz gráfica que podremos usar a través de la aplicación “Escritorio remoto” incluida en Windows 10.
1. Habilitar WSL e instalar Kali Linux en Windows 10
Lo primero comentaros que si ya tienen instalado Kali Linux teniendo habilitado WSL ir al paso 2. Sino seguir estos pasos primero, son necesarios para poder ejecutarlo de forma correcta en Windows 10.
Habilitar WSL Windows Subsystem Linux
Es necesario habilitar WSL antes de instalar y ejecutar Kali Linux desde el Microsoft Store, sino lo habilitamos WSL, podréis ver que al intentar ejecutar Kali os aparecerá el "error: 0x8007007e".
Para activar WSL (Windows Subsystem for Linux) necesitaremos abrir un PowerShell con derechos administativos, para eso abrimos una carpeta desde el Explorador de archivos (no puede ser carpeta de sistema) y vamos a esta ruta:
Archivo
Abrir Windows PowerShell (como Administrador)
Y en la nueva Shell abierta introducir el siguiente comando:
Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux
Como veis en la última pantalla, os pedirá que escribáis "Y" y pulsar "Enter" para reiniciar y que se aplique el estar habilitado WSL en tu equipo Windows 10. Con esto ya esta activado WSL.
2.-Instalar Kali Linux desde Microsoft Store
Ahora una vez habilitado WSL procedemos a instalar Kali Linux desde Microsoft Store.
Buscamos Kali en el Store y pulsamos en "Obtener" y empezará la descarga e instalación, que ronda los 134MB.
Llegará el punto que aparecerá que está instalado y podremos pulsar en "Iniciar" o "Anclar a Inicio". Una vez iniciado Kali Linux procedemos a su configuración básica, introducimos el nombre de usuario, clave dos veces y ya estaremos en el promt de nuestro Kali Linux.
3. Instalar interfaz gráfica Kali Linux en Windows 10
Para instalar una interfaz gráfica necesitaremos ejecutar los siguientes comandos, cabe destacar que el proceso es largo al tener que descargar una gran cantidad de paquetes.
Para "Actualizar" nuestro Kali:
sudo apt update && sudo apt -y dist-upgrade
Y esperamos a que complete.
Para instalar el entorno de escritorio de Kali, paciencia tarda bastante tiempo.
sudo apt -y install kali-desktop-xfce
Cuando lo solicite elegimos el teclado correspondiente y esperamos a que complete.
Para instalar sistema X window versión 11 XORG:
sudo apt -y install xorg (por si no se instalo)
Para Instalar el Escritorio remoto Linux por Terminal Server XRDP:
sudo apt -y install xrdp
Cuando termine de instalar lo configuramos con este comando:
sudo sed -i 's/port=3389/port=3390/g' /etc/xrdp/xrdp.ini
Ponemos en marcha el servidor XRDP:
sudo /etc/init.d/xrdp start
Con esto ejecutado solo nos queda conectarnos con Escritorio remoto. Recordar que tenemos que tenerlo habilitado en Windows 10. Aquí dejamos como hacerlo en caso de que no lo tuvierais activo.
Debemos abrir el Escriorio remoto y escribir lo siguiente:
127.0.0.1:3389 o 127.0.0.1:3390
En el ejemplo usamos el puerto 3390.
Y colocar las credenciales de nuestra cuenta.
A veces tarda en iniciar por primera vez, se queda en pantalla negra, basta con reiniciar la conexión.
Con esto ya tendremos nuestro Kali Linux con interfaz gráfica totalmente operativo e instalado desde Windows 10.

10
Instalar apps en la fonera.txt Normal file
View File

@ -0,0 +1,10 @@
1.- Editar fichero /etc/opkg.conf e introducir la línea: dest usb /tmp/mounts/Disc-A1 o dest usb /tmp/run/mountd/sda1
2.- Instalar los paquetes que queramos, por ejemplo el nano (y sus dependencias si las hubiese):
opkg -d usb install http://downloads.openwrt.org/kamikaze/8.09.2/brcm47xx/packages/nano_2.0.7-1_mipsel.ipk
opkg -d usb install http://downloads.openwrt.org/kamikaze/8.09.2/brcm47xx/packages/libncurses_5.6-1_mipsel.ipk
3.- Definir las vbles de entorno PATH y LD_LIBRARY_PATH para poder ejecutar las apps:
export PATH=/bin:/sbin:/usr/bin:/usr/sbin:/tmp/run/mountd/sda1/usr/bin/
export LD_LIBRARY_PATH=/lib:/usr/lib:/tmp/run/mountd/sda1/usr/lib/
¡¡¡¡¡¡¡LISTOS!!!!!!!

13
Limpiar cachés y cookies de navegadores.txt Normal file
View File

@ -0,0 +1,13 @@
Limpiar cachés y cookies:
Safari
https://support.apple.com/es-es/guide/safari/sfri11471/mac
Chrome
https://support.google.com/accounts/answer/32050?co=GENIE.Platform%3DDesktop&hl=es
Firefox
https://support.mozilla.org/es/kb/limpia-la-cache-y-elimina-los-archivos-temporales-
Internet Explorer
https://support.microsoft.com/es-es/help/278835/how-to-delete-cookie-files-in-internet-explorer

BIN
Linux/Integration Ubuntu Desktop with AD.pdf Normal file
View File

Binary file not shown.

23
Linux/actualizar repositorios nginx a los oficiales e importacion clave publica.txt Normal file
View File

@ -0,0 +1,23 @@
Hemos editado /etc/apt/sources.list y añadido lo siguiente al final del archivo de cada una de las máquinas solicitadas
deb [arch=amd64] https://nginx.org/packages/ubuntu/ focal nginx
deb-src [arch=amd64] https://nginx.org/packages/ubuntu/ focal nginx
Después hemos realizado una actualización de los repositorios
sudo apt-get update
Al final del escaneo nos ha indicado que no ha podido encontrar NO_PUBKEY ABF5BD827BD9BF62
Para solucionar esto se ha procedido a lanzar este comando
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys ABF5BD827BD9BF62
Este comando al lanzarlo da como resultado un fallo debido a que no está abierto en nuestro firewall el puerto 11371 que es el que usa GPG.
Para solucionarlo se ha forzado que se utilice el puerto 80 con el siguiente comando
sudo apt-key adv --recv-keys --keyserver hkp://keyserver.ubuntu.com:80 ABF5BD827BD9BF62
A continuación hemos procedido a realizar la instalación de nuestra nueva versión de NGINX
sudo apt-get install nginx
sudo systemctl enable nginx
sudo systemctl start nginx
sudo systemctl status nginx

BIN
Linux/alta disponibilidad con pcs corosync y pacemaker.pdf Normal file
View File

Binary file not shown.

45
Linux/ampliar disco linux online con LVM.txt Normal file
View File

@ -0,0 +1,45 @@
Aumentar espacio linux (con LVM):
https://www.rootusers.com/how-to-increase-the-size-of-a-linux-lvm-by-expanding-the-virtual-machine-disk/
1: Ampliar el disco físico o añadir uno nuevo (VMware).
2: Reescanear el bus SCSI en busca de cambios (los nº de host o IDs de dispositivo pueden ser diferentes, se puede hacer en todos):
echo "- - -" > /sys/class/scsi_host/host0/scan
ó
echo 1 > /sys/class/scsi_device/0\:0\:3\:0/device/rescan
3: Comprobar que se ha detectado el tamaño nuevo del disco físico:
fdisk -l
4: Crear una nueva partición (primaria, tipo 8E):
fdisk /dev/sdc (sdc o el dispositivo que corresponda)
n (nueva partición)
p (primaria)
<enter> (nº de partición por defecto, tomar nota)
<enter> (posición inicial, por defecto)
<enter> (tamaño, por defecto todo el espacio libre)
t (cambiar tipo de partición)
<nº> (nº de partición que se acaba de crear)
8e (tipo de partición 8E)
w (escribir cambios y salir)
En este ejemplo se ha creado la partición /dev/sdc2
5: Forzar una re-lectura de la tabla de particiones (para evitar reiniciar):
partprobe -s
ó
partx -a /dev/sdc2
ó
partx -a /dev/sdc
6: Comprobar que se lista la nueva partición:
fdisk -l
7: Crear un volumen físico LVM en la nueva partición:
pvcreate /dev/sdc2
8: Confirmar el nombre del grupo de volúmenes LVM que hay que ampliar (en este ejemplo "almacen"):
vgdisplay (tomar nota de "VG Name")
9: Extender el grupo de volúmenes LVM añadiendo el volumen físico LVM que acabamos de crear:
vgextend almacen /dev/sdc2
10: Confirmar que se ha añadido correctamente:
pvscan
11: Confirmar la ruta del volumen lógico LVM que hay que ampliar (en este ejemplo "/dev/almacen/almacen"):
lvdisplay (tomar nota de "LV Path")
12: Extender el volumen lógico LVM:
lvextend /dev/almacen/almacen /dev/sdc2
13: Extender el sistema de ficheros (puede tardar unos minutos):
** ext-2/-3/-4 ** : resize2fs /dev/almacen/almacen
** xfs ** : xfs_growfs /dev/almacen/almacen

742
Linux/awk.txt Normal file
View File

@ -0,0 +1,742 @@
Uso del comando AWK en Linux y UNIX con ejemplos
Eliminar espacios en blanco del princpio de una cadena:
echo $cadena | awk '{sub(/^[ \t]+/, ""); print }'
MOSTRAR EN PANTALLA LAS COLUMNAS QUE QUERAMOS
A continuación veremos una serie de ejemplos que nos ayudarán a comprender como podemos manipular las columnas con el comando awk
Extraer las columnas que queramos de un determinado texto
El comando Awk nos permite seleccionar una columna determinada y mostrarla en pantalla. En mi caso ejecutando el comando ps obtengo la siguiente salida:
joan@gk55:~$ ps
PID TTY TIME CMD
636856 pts/1 00:00:00 bash
636889 pts/1 00:00:00 ps
Si únicamente queremos mostrar la columna PID ejecutaremos un comando del siguiente tipo:
ps | awk '{print $num_columna}'
Como el número de columna es la 1 entonces ejecutaremos el siguiente comando obteniendo el siguiente resultado.
joan@gk55:~$ ps | awk '{print $1}'
PID
636856
637797
637798
Nota: Colocamos '{}' y dentro de las llaves que introducimos/escribimos la acción que queremos realizar que en este caso es imprimir la columna 1.
Nota: El delimitador por defecto de awk es el espacio. Por lo tanto cada espacio que haya en la salida de texto será considerado como un cambio de columna. Más adelante verán que se puede cambiar el delimitador por defecto.
Si en vez de la primera columna quisiéramos imprimir la segunda ejecutaríamos el siguiente comando:
joan@gk55:~$ ps | awk '{print $2}'
TTY
pts/3
pts/3
pts/3
Si quisiéramos mostrar la primera columna sin mostrar la primera fila entonces ejecutaríamos el siguiente comando:
joan@gk55:~$ ps | awk 'NR>1{print $2}'
pts/3
pts/3
pts/3
Nota: Más adelante encontrarán más ejemplos y explicaciones para entender el uso del parámetro NR.
Cambiar el delimitador por defecto en Awk y extraer la primera columna
En el primer apartado hemos visto que el delimitador por defecto de awk es el espacio, pero en caso de necesidad podemos definir el delimitador que más nos convenga. Imaginemos que ejecutando el comando cat /etc/passwd obtenemos la siguiente salida:
joan@gk55:~$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
...
Si únicamente queremos mostrar los usuarios del sistema operativo borrando el resto de información tendremos que:
Fijar : como delimitador.
Imprimir la primera columna.
Para hacer lo que acabo de citar ejecutaremos un comando del siguiente tipo:
cat /etc/passwd | awk -F "delimitador" '{print $num_columna}'
Como el delimitador y el número de columna son : y 1 ejecutaré el siguiente comando obteniendo el siguiente resultado:
joan@gk55:~$ cat /etc/passwd | awk -F ":" '{print $1}'
root
daemon
bin
sys
sync
games
...
Extraer varias columnas de texto de forma simultánea con el comando awk
Si queremos extraer varias columnas de forma simultánea lo haremos del siguiente modo:
joan@gk55:~$ cat /etc/passwd | awk -F ":" '{print $1 $3 $4}'
root00
daemon11
bin22
sys33
sync465534
games560
...
La salida es difícil de leer e interpretar porque se imprimen las columnas sin dejar espacios entre ellas. Si queremos añadir espacios entre columnas lo haremos añadiendo los caracteres " " entre las columnas que seleccionamos para imprimir. Por lo tanto para hacer más legible el resultado anterior ejecutaremos el siguiente comando:
joan@gk55:~$ cat /etc/passwd | awk -F ":" '{print $1" "$3" "$4}'
root 0 0
daemon 1 1
bin 2 2
sys 3 3
sync 4 65534
games 5 60
...
Si en vez de un espacio quisiéramos añadir una tabulación reemplazaríamos " " por "\t" obteniendo el siguiente resultado:
joan@gk55:~$ cat /etc/passwd | awk -F ":" '{print $1"\t"$3"\t"$4}'
root 0 0
daemon 1 1
bin 2 2
sys 3 3
sync 4 65534
games 5 60
...
Nota: Otra opción para hacer que el formato sea más legible sería usar printf en vez de print. Más adelante veréis ejemplos de como se puede usar printf.
Fijar un delimitador con la opción FS e imprimir varias columnas
Mediante la opción FS «Field Separator» también podemos fijar un delimitador. Para ello deberemos usar un comando del siguiente tipo:
awk 'BEGIN{FS=":";} {print $1"\t"$3"\t"$4}'
Por lo tanto si volvemos al caso del apartado anterior y queremos imprimir las columnas 1, 3 y 4 lo haremos del siguiente modo:
joan@gk55:~$ cat /etc/passwd | awk 'BEGIN{FS=":";} {print $1"\t"$3"\t"$4}'
root 0 0
daemon 1 1
bin 2 2
sys 3 3
sync 4 65534
games 5 60
...
Nota: El comando ejecutado es equivalente a awk 'BEGIN{FS=":";} {print $1"\t"$3"\t"$4}' /etc/passwd o al cat /etc/passwd | awk -F ":" '{print $1"\t"$3"\t"$4}'
Nota: Toda acción definida dentro de las llaves de BEGIN se ejecuta antes de procesar el fichero de texto /etc(passwd)
Combinar el uso de FS con OFS en awk para tener un delimitador en la salida mostrada en pantalla
Si queremos combinar el uso de FS «field separator» con OFS «Output field separator» tendremos que proceder del siguiente modo.
La opción FS sirve para fijar el separador y la opción OFS define el separador de salida que usaremos para mostrar las columnas seleccionadas en pantalla.
Por ejemplo si queremos mostrar las columnas 1, 3 y 4 del comando cat etc/passwd y que las columnas de salida estén separadas por - entonces usaremos el siguiente comando:
joan@gk55:~$ cat /etc/passwd | awk 'BEGIN{FS=":";OFS=" - "} {print $1,$3,$4}'
root - 0 - 0
daemon - 1 - 1
bin - 2 - 2
sys - 3 - 3
sync - 4 - 65534
games - 5 - 60
...
Imprimir en pantalla únicamente el último delimitador de una salida con awk mediante $NF
Imaginemos que la salida del comando cat /etc/shells es la siguiente:
joan@gk55:~$ cat /etc/shells
# /etc/shells: valid login shells
/bin/sh
/bin/bash
/usr/bin/bash
/bin/rbash
/usr/bin/rbash
/bin/dash
/usr/bin/dash
Si os fijáis, el nombre de la shell a veces está en la segunda columna y a veces en la tercera columna. Pero lo que es común en todas las salidas es que el nombre de la shell esté en el último delimitador. Para Imprimir el contenido que está después del último delimitador ejecutaremos un comando del siguiente tipo:
awk -F "/" '/^\// {print $NF}'
Cada uno de los parámetros del comando que acabáis de leer hace lo siguiente:
-F "/": Establecemos que el delimitador usado por awk será /
/^\//: Entre // introducimos ^\/ que es una expresión regular que significa toda línea que empiece por /
{print $NF}: Hace referencia a imprimir el último delimitador en todas las líneas que se cumpla la expresión regular ^\/
Si ahora llevamos la teoría a la práctica ejecutaremos el siguiente comando obteniendo el siguiente resultado:
joan@gk55:~$ awk -F "/" '/^\// {print $NF}' /etc/shells
sh
bash
bash
rbash
rbash
dash
dash
El comando anterior veréis que muestra shells duplicadas. Si queremos eliminar las shell duplicadas usaremos el comando uniq del siguiente modo:
joan@gk55:~$ awk -F "/" '/^\// {print $NF}' /etc/shells | uniq
sh
bash
rbash
dash
Imprimir el contenido del penúltimo o antepenúltimo delimitador mediante $NF
En el apartado anterior imprimimos el contenido del último delimitador. Si queremos imprimir el penúltimo tan solo tenemos que reemplazar $NF por %(NF-1). Si lo hacemos el resultado obtenido será:
joan@gk55:~$ awk -F "/" '/^\// {print $(NF-1)}' /etc/shells
bin
bin
bin
bin
bin
bin
bin
Si quisiéramos imprimir el antepenúltimo delimitador deberíamos usar $(NF-2)
joan@asus:~$ awk -F "/" '/^\// {print $(NF-2)}' /etc/shells
usr
usr
usr
OPERAR CON LÍNEAS DE TEXTO MEDIANTE EL COMANDO AWK
Hasta el momento hemos visto varios métodos para imprimir las columnas de texto que nos interesan. Del mismo modo que imprimimos las columnas de texto que nos interesan también podemos imprimir las filas o líneas de texto que nos interesen. Para ello deberéis proceder del siguiente modo.
Imprimir únicamente las líneas que sigan un determinado patrón
En mi caso la salida del comando df es la siguiente:
joan@gk55:~$ df
S.ficheros bloques de 1K Usados Disponibles Uso% Montado en
udev 3949508 0 3949508 0% /dev
tmpfs 797996 1304 796692 1% /run
/dev/sda5 28767268 13356764 13926168 49% /
tmpfs 3989968 31068 3958900 1% /dev/shm
tmpfs 5120 4 5116 1% /run/lock
tmpfs 3989968 16 3989952 1% /tmp
/dev/sda4 66559996 26678488 39881508 41% /media/DATOS
/dev/sda6 40054040 16034856 21954800 43% /home
/dev/sda8 507904 50252 457652 10% /boot/efi
tmpfs 797992 56 797936 1% /run/user/1000
Si únicamente queremos mostrar en pantalla las líneas que empiezan por / usaremos un comando del siguiente tipo:
df | awk '/expresión_regular/ {print}'
En el apartado anterior hemos visto que la expresión regular para definir todas las líneas que empiezan por / es ^\/. Por lo tanto el comando para que únicamente se muestren las líneas que empiecen por / será el siguiente:
joan@gk55:~$ df | awk '/^\// {print}'
/dev/sda5 28767268 13356764 13926168 49% /
/dev/sda4 66559996 26678488 39881508 41% /media/DATOS
/dev/sda6 40054040 16033804 21955852 43% /home
/dev/sda8 507904 50252 457652 10% /boot/efi
Y si únicamente queremos mostrar la línea que empieza por /dev/sda5 ejecutaremos el siguiente comando:
joan@gk55:~$ df | awk '/^\/dev\/sda5/ {print}'
/dev/sda5 28767268 13356764 13926168 49% /
Mostrar únicamente las líneas que empiezan o finalizan por un determinado patrón
Anteriormente ya hemos visto ejemplos para imprimir únicamente las líneas que empiezan por una letra determinada o por un patrón determinado. Por lo tanto para imprimir las líneas de la salida del comando df que empiezan por la palabra tmpfs ejecutaremos el siguiente comando:
joan@gk55:~$ df | awk '/^tmpfs/ {print}'
tmpfs 298144 916 297228 1% /run
tmpfs 1490708 149436 1341272 11% /dev/shm
tmpfs 5120 4 5116 1% /run/lock
tmpfs 298140 56 298084 1% /run/user/1000
Si ahora queremos mostrar únicamente las líneas que terminan por /shm deberemos cambiar la expresión regular ^tmpfs por \/shm$. De este modo podéis ver que conseguimos nuestro objetivo:
joan@gk55:~$ df | awk '/\/shm$/ {print}'
tmpfs 1490708 155580 1335128 11% /dev/shm
Y si únicamente quisiéramos mostrar las líneas que empiezan por tmpfs y a la vez terminan por /shm lo haríamos del siguiente modo:
joan@gk55:~$ df | awk '/\/shm$/ && /^tmpf/ {print}'
tmpfs 1490708 134808 1355900 10% /dev/shm
Mostrar las columnas que queramos de únicamente las líneas que cumplen una determinada condición
En el ejemplo del apartado anterior se mostraban la totalidad de columnas de las líneas que empiezan por /. Si en vez de mostrar todas las columnas tan solo quiero mostrar la 1, la 2 y la 3 procederemos del siguiente modo:
joan@gk55:~$ df -h | awk '/^\// {print $1"\t"$2"\t"$3}'
/dev/sda5 28G 13G
/dev/sda4 64G 26G
/dev/sda6 39G 16G
/dev/sda8 496M 50M
Si ahora queremos sumar las columnas 2 y 3 para obtener el espacio total de cada partición lo podemos hacer del siguiente modo:
joan@gk55:~$ df -h | awk '/^\// {print $1"\t"$2 + $3}'
/dev/sda5 41
/dev/sda4 90
/dev/sda6 55
/dev/sda8 546
Y si queremos que se siga mostrando la unidad de capacidad de almacenamiento:
joan@gk55:~$ df -h | awk '/^\// {print $1"\t"$2 + $3"G"}'
/dev/sda5 41G
/dev/sda4 90G
/dev/sda6 55G
/dev/sda8 546G
Mostrar únicamente las líneas que tengan una longitud de caracteres determinada mediante lenght
Si queremos imprimir las líneas del fichero /etc/shells que tienen una longitud superior a 9 caracteres ejecutaremos el siguiente comando:
joan@gk55:~$ awk ' length($0) > 9 ' /etc/shells
# /etc/shells: valid login shells
/usr/bin/bash
/bin/rbash
/usr/bin/rbash
/usr/bin/dash
Nota: Del mismo modo que hemos usado length($0) > 9 podríamos haber usado length($0) < 9, length($0) == 9 o length($0) != 9.
Mostrar filas que deben cumplir con varias condiciones de forma simultanea con el operador &&
Mediante el operador && podemos imprimir o mostrar las líneas que cumplan con 2 o más condiciones. Por ejemplo si queremos mostrar las líneas de salida del comando df -h que empiezan por t y cuya columna 6 tenga más de 8 caracteres ejecutaremos el siguiente comando:
joan@gk55:~$ sudo df -h | awk ' /^t/ && length($6) > 8 {print $0} '
tmpfs 5,0M 4,0K 5,0M 1% /run/lock
tmpfs 292M 52K 292M 1% /run/user/1000
Ver la longitud de cada una de las líneas con el comando awk mediante ‘{print length}’
Para saber el número de caracteres de cada una de las líneas del fichero /etc/shells lo haremos mediante el siguiente comando:
joan@gk55:~$ awk '{print length}' /etc/shells
33
7
9
13
10
14
9
13
Si además de escribir el número de caracteres también queremos escribir el contenido de la línea:
joan@gk55:~$ awk '{print length"\t"$0}' /etc/shells
33 # /etc/shells: valid login shells
7 /bin/sh
9 /bin/bash
13 /usr/bin/bash
10 /bin/rbash
14 /usr/bin/rbash
9 /bin/dash
13 /usr/bin/dash
En este apartado hemos visto como imprimir el número de caracteres de un línea entera. Si únicamente queremos imprimir el número de caracteres de la columna 1 de la salida del comando df -h lo haremos del siguiente modo:
joan@gk55:~$ sudo df -h | awk '{print length($1)"\t"$1}'
10 S.ficheros
4 udev
5 tmpfs
9 /dev/sda1
5 tmpfs
5 tmpfs
10 compartida
5 tmpfs
Y si queremos eliminar la primera de la salida del comando df añadiríamos el parámetro NR>1 del siguiente modo:
joan@gk55:~$ sudo df -h | awk 'NR>1{print length($1)"\t"$1}'
4 udev
5 tmpfs
9 /dev/sda1
5 tmpfs
5 tmpfs
10 compartida
5 tmpfs
Imprimir la longitud de únicamente las líneas que tengan un determinado número de caracteres
Si ahora queremos imprimir la longitud de únicamente las líneas que tienen una longitud superior a 9 caracteres tan solo tenemos que combinar los comandos de los últimos apartados del siguiente modo:
joan@gk55:~$ awk ' length($0) > 9 {print length} ' /etc/shells
33
13
10
14
13
Imprimir todas las líneas cuyo el último delimitador sea igual a una determinada palabra mediante el condicional if
En mi caso la salida del comando ps -ef es la siguiente:
joan@gk55:~$ ps -ef
UID PID PPID C STIME TTY TIME CMD
root 1 0 0 17:11 ? 00:00:01 /sbin/init
root 2 0 0 17:11 ? 00:00:00 [kthreadd]
root 3 2 0 17:11 ? 00:00:00 [rcu_gp]
root 4 2 0 17:11 ? 00:00:00 [rcu_par_gp]
...
Si queremos obtener un listado de procesos cuyo último delimitador contenga la palabra firefox podemos usar lo aprendido hasta ahora conjuntamente con el comando if. Para conseguir nuestro propósito lo haremos del siguiente modo:
joan@gk55:~$ ps -ef | awk '{ if($NF == "firefox") print $0}'
joan 12642 1 0 09:42 ? 00:00:00 /bin/sh -c firefox
joan 12643 12642 14 09:42 ? 00:59:13 firefox
Nota: Podemos usar varios operadores como por ejemplo ==, !=, >, <
Nota: En apartados anteriores hemos visto que el último delimitador se define como $NF.
Nota: $0 hace referencia a todas las columnas.
Si únicamente quisiéramos imprimir el número de proceso y el último delimitador usaríamos el siguiente comando:
joan@gk55:~$ ps -ef | awk '{ if($NF == "firefox") print $2" "$NF}'
12642 firefox
12643 firefox
Contar el número de líneas de un fichero o de la salida de un comando con NR (Número de registros)
Para mostrar el número de líneas que tiene un fichero o la salida de un comando usaremos el parámetro NR. Por lo tanto para imprimir el número de líneas que tiene el fichero /etc/shells lo haremos del siguiente modo:
joan@gk55:~$ awk '{print NR}' /etc/shells
1
2
3
4
5
6
7
8
Sí únicamente queremos obtener el número total de líneas añadiremos el parámetro END del siguiente modo:
joan@gk55:~$ awk 'END {print NR}' /etc/shells
8
Nota: Toda acción precedida del comando END solo se ejecutará una vez cuando se haya procesado la salida del fichero /etc/shells
Imprimir la primera línea de un fichero o de la salida de un comando con la opción NR
La opción NR también no servirá para imprimir la línea de texto que nosotros queramos. Por ejemplo si queremos imprimir la primera línea de la salida del comando ps -aux lo haremos del siguiente modo:
joan@gk55:~$ ps -aux | awk 'NR==1{print $0}'
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
Y si únicamente queremos imprimir la segunda línea lo haremos así:
joan@gk55:~$ ps -aux | awk 'NR==2{print $0}'
root 1 0.0 0.3 163980 9400 ? Ss 08:52 0:01 /sbin/init
Imprimir todas las filas de un fichero a partir de una determinada línea mediante la opción NR
Para imprimir todas las líneas de la salida del comando ps -aux excepto las 2 primeras lo haremos de forma similar al apartado anterior, pero en vez de usar el operador == usaremos el operador >
joan@gk55:~$ ps -aux | awk 'NR>2{print $0}'
root 2 0.0 0.0 0 0 ? S 08:52 0:00 [kthreadd]
root 3 0.0 0.0 0 0 ? I< 08:52 0:00 [rcu_gp]
root 4 0.0 0.0 0 0 ? I< 08:52 0:00 [rcu_par_gp]
...
Lo que estamos haciendo con el comando ejecutado es imprimir todos los registros del fichero excepto el 1 y el 2 que corresponden obviamente a la primera y segunda línea.
Imprimir todas las línea de un documento o salida que empiezan con un determinado carácter o string
Si quisiéramos imprimir todos los procesos que están corriendo en nuestro sistema operativo podemos usar el siguiente comando:
joan@gk55:~$ ps -aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.3 163980 9388 ? Ss 08:52 0:01 /sbin/init
root 2 0.0 0.0 0 0 ? S 08:52 0:00 [kthreadd]
root 3 0.0 0.0 0 0 ? I< 08:52 0:00 [rcu_gp]
root 4 0.0 0.0 0 0 ? I< 08:52 0:00 [rcu_par_gp]
...
En la primera columna $1 figura el usuario que ha iniciado el proceso. Si queremos imprimir los detalles de los procesos iniciados por usuario cuyo nombre empieza por a o por m, lo haremos del siguiente modo:
joan@gk55:~$ ps -aux | awk '$1 ~ /^[a,m]/ {print $0}'
avahi 451 0.0 0.1 7272 3132 ? Ss 08:52 0:00 avahi-daemon: running [asus.local]
message+ 455 0.0 0.1 8908 4572 ? Ss 08:52 0:01 /usr/bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation --syslog-only
avahi 471 0.0 0.0 7092 316 ? S 08:52 0:00 avahi-daemon: chroot helper
Si queremos el mismo resultado que acabamos de obtener mostrando la cabecera que en este caso será la primera línea lo haremos del siguiente modo:
joan@gk55:~$ ps -aux | awk 'NR==1{print $0}' && ps -aux | awk '$1 ~ /^[a,m]/ {print $0}'
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
avahi 451 0.0 0.1 7272 3096 ? Ss 08:52 0:00 avahi-daemon: running [asus.local]
message+ 455 0.0 0.1 8908 4572 ? Ss 08:52 0:01 /usr/bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation --syslog-only
avahi 471 0.0 0.0 7092 304 ? S 08:52 0:00 avahi-daemon: chroot helper
Imprimir eliminando los x primero caracteres de cada línea mediante el parámetro substr
En mi caso la salida del comando /etc/shells es la siguiente:
joan@gk55:~$ cat /etc/shells
# /etc/shells: valid login shells
/bin/sh
/bin/bash
/usr/bin/bash
/bin/rbash
/usr/bin/rbash
/bin/dash
Si queremos imprimir la salida eliminando por ejemplo los 5 primeros caracteres de cada una de las líneas lo haremos del siguiente modo:
joan@gk55:~$ cat /etc/shells | awk '{print substr($0, 5)}'
etc/shells: valid login shells
/sh
/bash
/bin/bash
/rbash
/bin/rbash
/dash
/bin/dash
Como hemos visto anteriormente, si queremos borrar la primera línea de la salida del comando lo haremos mediante el parámetro NR>1 del siguiente modo:
joan@gk55:~$ cat /etc/shells | awk 'NR>1 {print substr($0, 5)}'
/sh
/bash
/bin/bash
/rbash
/bin/rbash
/dash
/bin/dash
Nota: El primer parámetro del comando substr sirve para definir la columna en la que operamos. El segundo parámetro es para definir los caracteres que queremos recortar.
Imprimir un rango de líneas determinadas mediante el comando awk y NR
Si en la salida del comando cat /etc/shells únicamente queremos imprimir las líneas o registros 2, 3 y 4 lo haremos del siguiente modo:
joan@gk55:~$ cat /etc/shells | awk 'NR==2, NR==4 {print $0}'
/bin/sh
/bin/bash
/usr/bin/bash
Si a la salida del comando que acabamos de ejecutar le quisiéramos añadir los número de línea lo haríamos del siguiente modo:
joan@gk55:~$ cat /etc/shells | awk 'NR==2, NR==4 {print NR, $0}'
2 /bin/sh
3 /bin/bash
4 /usr/bin/bash
Saber en que posición de una línea aparece una palabra o combinación de letras determinada mediante match y RSTART
Para saber la posición en que aparece una palabra o cadena de caracteres usaremos los parámetros match y RSTART. Su funcionamiento lo veréis en el siguiente ejemplo.
Para ver la posición en que aparece la palabra cpu en la salida del comando ps -aux ejecutaremos el siguiente comando:
joan@gk55:~$ ps -aux | awk 'match($0, /cpu/) {print $0 " Contiene la palabra \"cpu\" en la posición " RSTART}'
root 9 0.0 0.0 0 0 ? I< 08:52 0:00 [mm_percpu_wq] Contiene la palabra "cpu" a la posición 75
root 15 0.0 0.0 0 0 ? S 08:52 0:00 [cpuhp/0] Contiene la palabra "cpu" en la posición 69
root 16 0.0 0.0 0 0 ? S 08:52 0:00 [cpuhp/1] Contiene la palabra "cpu" en la posición 69
root 21 0.0 0.0 0 0 ? S 08:52 0:00 [cpuhp/2] Contiene la palabra "cpu" en la posición 69
La función match($0, /cpu/) busca todas las líneas que contienen un determinado patrón que en el caso del ejemplo es las letras cpu. Entonces mediante print y RSTART se imprimen o muestran en pantalla mostrando la posición en que aparece el patrón que estamos buscando.
Mostrar la longitud de un patrón mediante el parámetro RLENGHT
En el ejemplo del apartado anterior añadiremos que se muestre la longitud del patrón o texto que estamos buscando. Lo haremos con el parámetro RLENGTH del siguiente modo:
joan@gk55:~$ ps -aux | awk 'match($0, /cpu/) {print $0 " La longitud de la expresión buscada es " RSTART" La longitud del parámetro buscado es " RLENGTH}'
root 9 0.0 0.0 0 0 ? I< 08:52 0:00 [mm_percpu_wq] La longitud de la expresión buscada es 75 La longitud del parámetro buscado es 3
root 15 0.0 0.0 0 0 ? S 08:52 0:00 [cpuhp/0] La longitud de la expresión buscada es 69 La longitud del parámetro buscado es 3
root 16 0.0 0.0 0 0 ? S 08:52 0:00 [cpuhp/1] La longitud de la expresión buscada es 69 La longitud del parámetro buscado es 3
root 21 0.0 0.0 0 0 ? S 08:52 0:00 [cpuhp/2] La longitud de la expresión buscada es 69 La longitud del parámetro buscado es 3
joan 411346 0.0 0.1 11300 3040 pts/0 R+ 14:01 0:00 awk match($0, /cpu/) {print $0 " La longitud de la expresión buscada es " RSTART" La longitud del parámetro buscado es " RLENGTH} La longitud de la expresión buscada es 83 La longitud del parámetro buscado es 3
REALIZAR OPERACIONES MATEMÁTICAS CON EL COMANDO AWK
Awk permite realizar operaciones matemáticas con los números de un fichero de texto o con los números que generan las salidas de los comandos. También es capaz de por ejemplo realizar operaciones matemáticas con valores almacenados en variables. Algunos ejemplos de lo que acabo de citar son los siguientes.
Realizar operaciones matemáticas con variables y awk
Si tenemos una variable a al que le asignamos el valor 10 y una variable b al que le asignamos el valor 20 podemos ejecutar el siguiente comando:
joan@gk55:~$ awk -v a="10" -v b="20" 'BEGIN {print "La multiplicación de a x b es", a*b;}'
La multiplicación de a x b es 200
Nota: Tenemos que usar la BEGIN porque no hay ninguna salida de texto o fichero a procesar. Todo lo que está dentro de BEGIN se ejecuta antes de procesarse un fichero o la salida de un comando. En contraposición END es todo lo que se ejecuta después de haber sido procesado un fichero o una salida de comando.
Nota: La forma de asignar una variable en awk es -v variable="valor"
Awk también permite llamar a variables que tenemos declaradas en nuestra shell de bash. Para ello lo haremos del modo que se muestra en el siguiente ejemplo:
joan@gk55:~$ a=1.5
joan@gk55:~$ b=4
joan@gk55:~$ awk -v a="$a" -v b="$b" 'BEGIN {print "La multiplicación de a x b es", a*b;}'
La multiplicación de a x b es 6
Calcular la raíz cuadrada de un número mediante awk
Del mismo modo que realizamos una suma podemos realizar restas, divisiones, multiplicaciones, etc. Así que se queremos obtener la raíz cuadrada de 400 lo haremos del siguiente modo:
joan@gk55:~$ awk 'BEGIN{print sqrt(400)}'
20
También podemos obtener un listado que nos proporcione resultados de la raíz cuadrada de una serie de números. Para ello podemos hacer uso de un bucle for de la siguiente forma:
joan@gk55:~$ awk 'BEGIN { for(i=1; i<=10; i++) print "La raíz cuadrada de", i*i, "es", i;}'
La raíz cuadrada de 1 es 1
La raíz cuadrada de 4 es 2
La raíz cuadrada de 9 es 3
La raíz cuadrada de 16 es 4
La raíz cuadrada de 25 es 5
La raíz cuadrada de 36 es 6
La raíz cuadrada de 49 es 7
La raíz cuadrada de 64 es 8
La raíz cuadrada de 81 es 9
La raíz cuadrada de 100 es 10
Y en el caso que quisieran obtener la raíz cuadrada de todos los números existentes entre el 0 y el 1 lo podrían hacer del siguiente modo:
joan@gk55:~$ awk 'BEGIN { for(i=0; i<=1; i=i+0.00001) print "La raíz cuadrada de", i*i, "es", i;}'
...
...
...
La raíz cuadrada de 0.99986 es 0.99993
La raíz cuadrada de 0.99988 es 0.99994
La raíz cuadrada de 0.9999 es 0.99995
La raíz cuadrada de 0.99992 es 0.99996
La raíz cuadrada de 0.99994 es 0.99997
La raíz cuadrada de 0.99996 es 0.99998
La raíz cuadrada de 0.99998 es 0.99999
EJECUTAR SCRIPTS CON EL COMANDO AWK
Como dijimos en el inicio del artículo awk es un lenguaje de programación. Podemos construir funciones, bucles y generar scripts usando el lenguaje awk. En nuestro caso definiremos un script para trabajar con los resultados que nos devuelve el comando df.
joan@gk55:~$ sudo df
S.ficheros bloques de 1K Usados Disponibles Uso% Montado en
udev 1467404 0 1467404 0% /dev
tmpfs 298144 904 297240 1% /run
/dev/sda1 56648848 13155828 40582968 25% /
tmpfs 1490708 351400 1139308 24% /dev/shm
tmpfs 5120 4 5116 1% /run/lock
compartida 499451928 415539964 83911964 84% /media
tmpfs 298140 56 298084 1% /run/user/1000
Lo que hará el script será lo siguiente:
Mostrar solo las líneas que empiecen por la letra t y cuya capacidad disponible (Columna 4 «$4») sea mayor a 6000k
De las columnas que se pueden mostrar solo imprimiremos en pantalla la (Columna 1 «$1»), que corresponde a la unidad, y la suma de la columnas 2 y 3 que corresponderá al espacio disponible.
Para generar un script simple con nombre capacidad.awk ejecutaremos el siguiente comando:
joan@gk55:~$ nano capacidad.awk
Una vez se abra el editor de textos escribiremos las instrucciones para conseguir nuestro propósito. En nuestro caso el código es el siguiente:
#!/usr/bin/awk -f
BEGIN { printf "%s\n","Voy a extraer las partes que me interesan del comando df" }
BEGIN { printf "%s\t%s\n","Unidad","Capacidad disponible" }
/^t/ && $4 > 6000 {print $1"\t"$2 + $3"K"}
Ahora ejecutaremos el script del siguiente modo y veremos que obtenemos el resultado deseado:
joan@gk55:~$ sudo df | awk -f capacidad.awk
Voy a extraer las partes que me interesan del comando df
Unidad Capacidad disponible
tmpfs 299048K
tmpfs 1845180K
tmpfs 298196K
Si también quisiéramos añadir las líneas que empiezan por c dejaríamos el script capacidad.awk del siguiente modo:
#!/usr/bin/awk -f
BEGIN { printf "%s\n","Voy a extraer las partes que me interesan del comando df" }
BEGIN { printf "%-12s %-3s\n","Unidad","Capacidad disponible" }
/^t/ && $4 > 6000 {printf "%-12s %-23s\n", $1, $2+$3"K"}
/^c/ && $4 > 6000 {printf "%-12s %-23d\n", $1, $2+$3"K"}
Nota: Si os fijáis en el contenido del script veremos que usamos la opción printf en lugar de print. De esta forma podemos dar formato a los datos de salida mostrados en pantalla. Los parámetros del comando printf harán lo siguiente:
%-: Justificar el texto a la izquierda.
%: Justificar el texto a la derecha.
12s: String de 12 caracteres.
23d: 23 caracteres con formato numérico decimal.
\n: Inserta una nueva línea.
Y el resultado obtenido seria el siguiente:
joan@gk55:~$ sudo df | awk -f capacidad.awk
Voy a extraer las partes que me interesan del comando df
Unidad Capacidad disponible
tmpfs 299048
tmpfs 1602408
compartida 923949580
tmpfs 298196
BUSCAR Y REEMPLAZAR TEXTO CON CON EL COMANDO AWK Y GSUB
Mediante la función gsub podemos buscar y reemplazar texto con awk de forma similar a como lo podemos hacer con sed. La función gsub se utiliza del siguiente modo:
gsub("letra_palabra_o_expresión_regular_a_buscar", "texto_que_reemplaza_el_buscado", lugar_donde_realizar_sustitución)
Buscar una expresión regular, palabra o letra y reemplazarla por otra
Por lo tanto si partimos del fichero de texto geekland.txt que tiene el siguiente contenido:
Geekland es el mejor blog, de tecnología
Y queremos reemplazar todas las G por g ejecutaremos el siguiente comando y obtendremos el siguiente resultado:
joan@gk55:~$ awk '{ gsub("G","g",$0); print $0 }' geekland.txt
geekland es el mejor blog, de tecnología
Buscar y reemplazar texto en únicamente una columna determinada
En nuestro caso la salida del comando df -h es la siguiente:
joan@gk55:~$ sudo df -h
S.ficheros Tamaño Usados Disp Uso% Montado en
udev 1,4G 0 1,4G 0% /dev
tmpfs 292M 916K 291M 1% /run
/dev/sda1 55G 13G 39G 25% /
tmpfs 1,5G 122M 1,4G 9% /dev/shm
tmpfs 5,0M 4,0K 5,0M 1% /run/lock
compartida 477G 408G 69G 86% /media
tmpfs 292M 68K 292M 1% /run/user/1000
Siguiendo el mismo procedimiento que en el apartado anterior, si en la segunda columna queremos reemplazar todas las M por G procederemos del siguiente modo:
joan@gk55:~$ sudo df -h | awk '{ gsub("M","G",$2); print $2 }'
Tamaño
1,4G
292G
55G
1,5G
5,0G
477G
292G
Si en vez de imprimir la primera columna queremos imprimir la primera y la segunda de forma que la tabulación sea perfecta usaremos printf del siguiente modo:
joan@gk55:~$ sudo df -h | awk '{ gsub("M","G",$2); printf "%-12s %-12s\n",$1,$2 }'
S.ficheros Tamaño
udev 1,4G
tmpfs 292G
/dev/sda1 55G
tmpfs 1,5G
tmpfs 5,0G
compartida 477G
tmpfs 292G

34
Linux/backup bbdd postgresql a directorio con retencion de 30 dias.txt Normal file
View File

@ -0,0 +1,34 @@
Este script realiza el backup de bases de datos postgresql a un directorio determinado y mantiene las copias durante 30 dias.
El contenido del script es el siguiente
#!/bin/bash
Tarea de Backup Bases de datos POSTGRESQL.*
backup_dir="/var/data/backup/"
#Añadimos la fecha de backup al nuevo archivo
backup_fecha=`date +%d-%m-%Y_%H-:%M`
#Número de días que vamos a mantener nuestros backups
numero_dias="30"
#Creamos lista de bases de datos para realizar backup
bases_de_datos=`sudo -u postgres /usr/bin/psql -l -t | cut -d'|' -f1 | sed -e 's/ //g' -e '/^$/d'`
#Comenzamos tarea de backup
#El nombre del fichero de backup dera: nombre de la base de datos + fecha + estensión .gz
for i in $bases_de_datos; do
if [ "$i" != "template0" ] && [ "$i" != "template1" ]; then
echo Volcamos $i a $backup_dir$i_$backup_fecha
sudo -u postgres /usr/bin/pg_dump -Fc $i|gzip > $backup_dir$i_$backup_fecha.gz
sudo chown postgres:postgres $backup_dir$i_$backup_fecha.gz
sudo chmod 700 $backup_dir$i_$backup_fecha.gz
fi
done
#Realizamos tareas de limpieza
sudo find $backup_dir -type f -prune -mtime +$numero_dias -exec rm -f {} \;

42
Linux/bbdd - mysql postgresql.txt Normal file
View File

@ -0,0 +1,42 @@
Cosas de mysql:
mysql -u root
CREATE DATABASE IF NOT EXISTS testdb /*DEFAULT CHARACTER SET utf8mb4*/;
DROP DATABASE testdb;
SHOW DATABASES;
SHOW TABLES FROM database;
SHOW COLUMNS FROM table.database;
SELECT default_character_set_name FROM information_schema.SCHEMATA WHERE schema_name = "testdb";
CREATE USER 'userdb'@'localhost' IDENTIFIED BY 'password';
DROP USER 'userdb'@'localhost';
UPDATE mysql.user SET Password=PASSWORD('new_password') WHERE USER='user' AND Host="host";
UPDATE mysql.user SET Password='cadena_larga_como_la_que_se_ve_en_el_select_de_abajo' WHERE USER='user' AND Host="host";
SELECT user,password,host FROM mysql.user;
SHOW GRANTS FOR 'Usuario'@'localhost';
SHOW processlist;
SHOW status like 'Threads%';
--- Threads_cached. Es el número de procesos cacheados actualmente.
--- Threads_connected. Número de conexiones activas actualmente.
--- Threads_create. Las conexiones que se han creado hasta el momento.
--- Threads_running. Las que se están ejecutando actualmente.
Cosas de postgresql:
Ver las bbdd:
SELECT pg_database.datname FROM pg_database;
Conectarse a una bbdd:
\c database_name;
Ver tablas de una bbdd:
\dt;
Consultar el tamaño de las bases de datos:
SELECT pg_database.datname, pg_size_pretty(pg_database_size(pg_database.datname)) AS size FROM pg_database;
Consultar el Top10 de las tablas de una base de datos que más espacio consumen:
SELECT relname as "Table", pg_size_pretty(pg_total_relation_size(relid)) As "Size", pg_size_pretty(pg_total_relation_size(relid) - pg_relation_size(relid)) as "External Size" FROM pg_catalog.pg_statio_user_tables ORDER BY pg_total_relation_size(relid) DESC LIMIT 10;
Consultar el tamaño de todos los objetos:
SELECT relname AS objectname, relkind AS objecttype, reltuples AS «#entries», pg_size_pretty(relpages::bigint*8*1024) AS size FROM pg_class ORDER BY relpages DESC;
Esta última consulta muestra 4 campos:
objectname: el nombre del objeto.
objecttype: r = tabla, i = índice, S = secuencia, v = vista, c = tipo compuesto, t = tabla TOAST.
#entries: el número de entradas en el objeto (p.ej. filas)
size: el tamaño del objeto.

39
Linux/bloqueo de actualizaciones de paquetes con bash y ansible.txt Normal file
View File

@ -0,0 +1,39 @@
Ejemplo de bloqueo de actualizaciones java:
sudo apt-mark hold openjdk-*-jdk-headless
sudo apt-mark hold openjdk-*-jdk-jre
sudo apt-mark hold openjdk-*-jre
sudo apt-mark hold openjdk-*-jre-headless
Para desbloquearlos hacer lo mismo pero con hunhold
sudo apt-mark unhold openjdk-*-jdk-headless
sudo apt-mark unhold openjdk-*-jdk-jre
sudo apt-mark unhold openjdk-*-jre
sudo apt-mark unhold openjdk-*-jre-headless
CON ANSIBLE SERIA (playbook):
# Prevent nginx from being upgraded
- dpkg_selections:
name: python
selection: hold
# Kept multiple packages back (hold packages)
- dpkg_selections: name={{ item }} selection=hold
with_items:
- apache2
- php7-fpm
- nginx
- mariadb-server
# Removing hold using Ansible
- dpkg_selections:
name: python
selection: install
Con yum se pueden ver los paquetes bloqueados con:
yum versionlock status

2
Linux/borrar ficheros con mas de x dias.txt Normal file
View File

@ -0,0 +1,2 @@
#borrado de backups con mas de 7 dias
find /home/user/backups/backup* -mtime +7 -exec rm {} \;

167
Linux/borrar nuestras huellas de Linux.txt Normal file
View File

@ -0,0 +1,167 @@
Borrar nuestras huellas
Este paso es importante, ya que de nada nos habrá servido habernos introducido en el sistema y haber conseguido el nivel de root si al día siguiente nos han cortado el acceso debido a que hemos dejado huellas por todas partes.
El sistema operativo Unix guarda varios registros (logs) de las conexiones de los usuarios al sistema. Existen varios ficheros y comandos que ayudan al administrador a conocer todos los detalles acerca de las conexiones de los usuarios. Aparte de estos ficheros y comandos, existen diversas facilidades y aplicaciones que realizan un registro continuado y exhaustivo acerca de las actividades del usuario dentro del sistema.
Ficheros:
(Cuando pongo dos directorios significa que el fichero puede estar en cualquiera de esos dos directorios).
utmp
Guarda un registro (log) de los usuarios que están utilizando el sistema mientras están conectados a él.
Directorios: /Var/Adm./utmp /etc/utmp
wtmp
Guarda un log cada vez que un usuario se introduce en el sistema o sale del sistema.
Directorios: /Var/Adm./wtmp /etc/wtmp
lastlog
Guarda un log del momento exacto en que un usuario entró por última vez.
Directorio: /Var/Adm./lastlog
acct
Registra todos los comandos ejecutados por cada usuario (aunque no registra los argumentos con que dichos comandos fueron ejecutados).
Directorio: /Var/adm/acct
En algunos sistemas el fichero acct se puede llamar pacct
Comandos:
who
Permite saber quién está conectado al sistema en el momento en que ejecutamos el comando.
finger
Lo mismo que el comando who, con el añadido de que se puede aplicar a otras máquinas. Es decir, podemos saber qué usuarios están conectados a una determinada máquina en el momento en que ejecutamos el comando.
users
Igual que el who
rusers
Igual que finger, pero la máquina remota debe utilizar el sistema operativo Unix.
Los comandos who, finger, users y rusers toman la información que sacan en pantalla del fichero utmp.
last
Permite saber cuando fue la última vez que se conectó un usuario.
El comando last toma la información que saca en pantalla del fichero wtmp.
ps
Permite saber qué procesos están siendo ejecutados por el sistema y que usuarios los ejecutan.
El comando ps ofrece una información mucho más completa de quién está utilizando el sistema puesto que un usuario que no aparezca en los ficheros utmp o wtmp puede tener procesos ejecutándose, por lo que el comando ps ofrecerá la información de quién está ejecutando dichos procesos. En contrapartida, la información que ofrece el comando ps es más complicada de interpretar que la información ofrecida por el resto de comandos.
accton
Activa un proceso llamado accounting, que es el que proporciona información al fichero acct.
lastcomm
Permite saber qué comandos han ejecutado los usuarios.
acctcom
Igual que lastcomm pero exclusivamente para Unix del tipo SYSTEM V.
Los comandos lastcomm y acctcom toman la información que sacan por pantalla del fichero acct (pacct en algunos sistemas).
Por lo tanto, si queremos borrar nuestras huellas del sistema, bastará con borrar cualquier log relativo a nuestro usuario de los ficheros utmp, wtmp y acct. Esto se puede hacer de dos formas:
Ficheros utmp y wtmp:
1 - No borramos los ficheros pero los dejamos con cero bytes. Sólo se utiliza como último recurso por suscitar muchas sospechas por parte de los administradores. Hay hackers que opinan que esto es incluso peor que no borrar los logs.
2 - Los ficheros utmp y wtmp no son ficheros de texto, es decir, no se pueden editar con un editor de textos. Sin embargo, existen programas llamados zappers (debido a que el programa más famoso de este tipo se llama zap) que pueden borrar los datos relativos a un usuario en particular de estos ficheros dejando el resto de los datos relativo a los demás usuarios intacto.
Fichero acct:
Cuando el accounting está activado (es decir, cuando el sistema recoge información acerca de los comandos ejecutados en el fichero acct) es bastante complicado borrar nuestras huellas, de hecho no se pueden borrar del todo, aunque sí se pueden reducir a una mínima información de nuestra presencia en el sistema.
1 - Lo primero que hacemos nada más entrar en el sistema es copiar el fichero acct a otro fichero y lo ultimo que hacemos antes de abandonar el sistema es copiar dicho fichero de nuevo al acct, de modo que los comandos que hemos ejecutado durante la sesión no aparecen en el fichero acct.
Problema: Nuestra entrada en el sistema queda registrada, así como las dos copias.
2 - Dejamos el fichero acct a cero bytes. Como antes, esto es bastante sospechoso para un administrador, además, algunos sistemas reaccionan mal y paran el proceso de accounting, para no levantar sospechas habría que reactivarlo con el comando accton.
Problema: Bastante sospechoso. El propio comando accton quedaría registrado como ejecutado por nuestro usuario.
3 - Hacerse un editor para el fichero acct que borrara los datos correspondientes a nuestro usuario y dejara intactos los datos relativos al resto de los usuarios. Existen unos pocos programas que hacen esto.
Problema: La ejecución del programa editor que borra nuestras huellas quedaría registrado como ejecutado por nuestro usuario.
Afortunadamente, no hay muchos sistemas que tengan activado el accounting debido a la cantidad de capacidad que es necesaria para guardar los comandos ejecutados por cada usuario.
Aparte de los ficheros utmp, wtmp, acct y lastlog, hay que tener en cuenta otras facilidades y aplicaciones que posee el sistema operativo Unix que permiten al administrador vigilar ciertos aspectos críticos relativos a la seguridad y al mantenimiento del sistema.
1 - Syslog
Syslog es una aplicación que viene con el sistema operativo Unix. El sistema operativo Unix se puede configurar de tal forma que determinados programas, procesos o aplicaciones generen mensajes que son enviados a determinados ficheros donde quedan registrados dichos mensajes. Estos mensajes son generados cuando se dan unas determinadas condiciones, ya sean condiciones relativas a seguridad, mantenimiento o simplemente de tipo puramente informativo.
Para conseguir esto hay que configurar varias cosas:
A - Decidir qué programas, procesos y aplicaciones pueden generar mensajes. (Pongo los principales)
kern: mensajes relativos al kernel.
user: mensajes relativos a procesos ejecutados por usuarios normales.
mail: mensajes relativos al sistema de correo.
lpr: mensajes relativos a impresoras.
auth: mensajes relativos a programas y procesos de autentificación (aquellos en los que estén involucrados nombres de usuarios y passwords, por ejemplo login, su, getty, etc).
daemon: mensajes relativos a otros demonios del sistema.
B - Decidir qué tipos de mensajes pueden generar cada uno de esos programas, procesos o aplicaciones.
emerg: emergencias graves.
alert: problemas que deben ser solucionados con urgencia.
crit: errores críticos.
err: errores ordinarios.
warning: avisos.
notice: cuando se da una condición que no constituye un error pero a la que se le debe dar una cierta atención.
info: mensajes informativos.
C - Decidir a qué ficheros van a parar dichos mensajes dependiendo del tipo al que pertenezca el mensaje correspondiente.
Syslog cumple su función mediante el syslogd (syslog daemon o en castellano el demonio syslog).
Nota: un demonio (o daemon) es un proceso que no tiene propietario (es decir, no es ejecutado por ningún usuario en particular) y que se está ejecutando permanentemente.
El syslogd lee su configuración del fichero /etc/syslog.conf Dicho fichero contiene la configuración relativa a qué eventos del sistema son registrados y en qué ficheros son registrados. Los ficheros a los cuales se mandan los registros (logs) pueden estar situados en la misma máquina en la que estamos trabajando o en otra máquina de la red.
Cómo borrar las huellas relativas al syslog:
Bien, nuestras andanzas por el sistema cuando hemos accedido a él y cuando nos hemos convertido en root, pueden generar diversos mensajes registrados por el syslogd y guardados en los ficheros indicados en el /etc/syslog.conf
A diferencia de los ficheros utmp, wtmp, acct y lastlog, los ficheros en los que se guardan los registros del syslog sí se pueden editar con un editor de textos.
Para poder borrar estas huellas necesitamos tener privilegios de root, naturalmente. Bastará con examinar el fichero /etc/syslog.conf para saber los ficheros que guardan los registros del syslog. Después miraremos cada uno de esos ficheros comprobando que no hay ningún mensaje relativo a nuestra intrusión en el sistema (los mensajes del estilo "login: Root LOGIN REFUSED on ttya" a ciertas horas de la noche son bastante sospechosos :-) ). En caso de que lo haya, lo borramos y cambiamos la fecha del fichero con el comando touch de forma que coincida la fecha del último mensaje (después de haber borrado nuestras huellas) con la fecha del fichero. Si no lo hacemos así, algún administrador demasiado suspicaz puede comprobar que las fechas no coinciden y deducir que alguien ha modificado el fichero (esta es una precaución extrema pero la recomiendo por experiencia). Si es necesario, y sólo si es necesario, habría que cambiar la fecha de los directorios en los que estén incluidos los ficheros que guardan los logs.
Si en el fichero /etc/syslog.conf hay mensajes que se destinan a /dev/console eso significa que los mensajes (ya sean de error, alerta o emergencia) salen directamente en la pantalla del root (o sea, en la consola). En este caso no se puede hacer nada (que yo sepa), pero mensajes de este tipo suelen estar generados por alertas bastante graves como por ejemplo intentar acceder con la cuenta de root directamente o utilizar el comando su para intentar convertirse en root, etc. Es decir, cuanto más sigilosos seamos a la hora de hacernos root y menos ruido armemos más posibilidades tendremos de no aparecer en este tipo de logs.
2 - TCP-Wrapper
Se trata de una aplicación que proporciona una serie de mecanismos para el registro (logging) y filtro (filtering) de aquellos servicios invocados o llamados a través del inetd (internet daemon). Con esta herramienta el administrador posee un control absoluto de las conexiones hacia y desde su máquina.
Puede, entre otras muchas cosas, filtrar un servicio de internet como por ejemplo el telnet, ftp, etc de forma que nadie pueda conectarse al sistema desde otra máquina o puede especificar una lista de máquinas que sí pueden conectarse (y las demás no podrán). Además, el administrador es informado en todo momento y con todo lujo de detalles de las conexiones que se han hecho desde su máquina y hacia su máquina con cualquiera de los diferentes servicios de internet (telnet, ftp, finger, etc...)
Como en el syslog, para borrar nuestras huellas del tcp-wrapper, tendremos que buscar posibles huellas mirando el archivo de configuración (alojado normalmente en el directorio /etc), borrar dichas huellas y cambiar las fechas de los ficheros correspondientes.
Bien, hasta aquí un resumen sobre cómo borrar las huellas. Como veréis me he extendido un poco más porque me parece importante que la gente adquiera conciencia de que tan importante o más que controlar el sistema (convertirse en root) es saber ocultarse en él (aunque es una opinión personal).
Puede parecer bastante pesado el borrar todas las posibles huellas que hayamos dejado, pero en algunas ocasiones, una vez que hayamos visto los ficheros de configuración es posible preparar un shell script (el equivalente a los ficheros batch en MS-DOS, aunque la programación en shell es infinitamente más potente :-) ) que haga todo el trabajo por nosotros en cuestión de borrar las huellas. Dicho script lo podemos dejar bien camuflado en el sistema para que la próxima vez que entremos lo podamos ejecutar (utilizando como parámetros el usuario con el que hayamos entrado, el terminal por el que hayamos entrado, la hora a la que hayamos entrado, etc..) ahorrándonos todo el trabajo pesado.
Para terminar con lo de borrar las huellas, sólo advertir que aunque seamos perfectamente invisibles en el sistema, cualquier usuario que esté conectado al mismo tiempo que nosotros podría detectarnos viendo el terminal por el que hemos entrado (el fichero /dev/ correspondiente a nuestro terminal tendría como propietario (owner) al usuario con el que hemos entrado en el sistema, y la fecha del fichero /dev/ correspondiente al terminal también nos delataría). Para evitar esto tendríamos que cambiar de owner el fichero correspondiente al terminal (teniendo privilegios de root naturalmente) al owner que tengan los otros terminales a los cuales no hay nadie conectado (es decir, al owner de los terminales por defecto que normalmente es el root).
De todas formas, esto último, junto con lo de cambiar de fecha ciertos ficheros de logs, son medidas quizá extremas, pero vuelvo a insistir que son muy recomendables.
Por último, la cuestión de ocultar o camuflar procesos mientras los estamos ejecutando es otra cuestión que se tratará en otro mensaje si tenéis la paciencia de seguir. :-)
Ya hemos visto de forma resumida y sin detallar algunas técnicas sobre cómo conseguir acceso, conseguir privilegios y borrar nuestras huellas. Vamos a ver el último paso, cómo conseguir acceso a otros ordenadores una vez controlado el host que hayamos hackeado (es decir, después de asegurarnos que hemos borrado absolutamente todas nuestras huellas y de implantar algún sushi u otro método análogo para conseguir privilegios de root).
Una vez controlado el host que teníamos como objetivo, podemos hacer todo lo que queramos en el sistema, aunque hay que tener en cuenta que nuestras acciones pueden ser registradas por el syslog, tcp-wrapper u otra utilidad que genere logs, por lo que cuando vayamos a irnos del sistema siempre tendremos que comprobar antes que no hemos dejado registros (logs).
Es en este punto donde adquiere importancia la "filosofía" del hacker. La diferencia entre un hacker y un cracker (no me estoy refiriendo a alguien que rompe las protecciones de software), consiste en que un cracker accede al sistema para dañarlo o corromperlo y un hacker accede al sistema simplemente para conseguir información o por pura curiosidad, pero nunca corromperá ni borrará ningún fichero del sistema, sigue el lema (aunque tampoco de forma radical, es decir, sin tomárselo al pie de la letra) de "se ve pero no se toca". A esto último hay que hacer una excepción , naturalmente. Los únicos ficheros que el hacker modificará o borrará serán los ficheros relativos a los logs que haya podido dejar en el sistema. Por supuesto que esto es una situación ideal y no realista, en la práctica un hacker puede que realice otras acciones en el sistema que puedan modificar ficheros ya existentes, pero siempre procurará que los cambios sean mínimos.

47
Linux/buscar subcadenas dentro de cadenas.txt Normal file
View File

@ -0,0 +1,47 @@
Usar caracteres comodín
El enfoque más simple es rodear la subcadena con el asterisco (asterisco) * símbolos comodín y compararlo con la cadena. El comodín es un símbolo que se utiliza para representar cero, uno o más caracteres.
Si la prueba devuelve verdadero, la subcadena está contenida en la cadena.
En el siguiente ejemplo, estamos usando la instrucción if y el operador de igualdad ( == ) para verificar si la subcadena SUB está dentro de la cadena STR:
#!/bin/bash
STR='GNU/Linux is an operating system'
SUB='Linux'
if [[ "$STR" == *"$SUB"* ]]; then
echo "Exists!"
fi
Una vez ejecutado, el script generará:
Exists!
Usando el asistente social
En lugar de usar la instrucción if, también puede usar la instrucción case para verificar si una cadena incluye otra cadena o no.
#!/bin/bash
STR='GNU/Linux is an operating system'
SUB='Linux'
case $STR in *"$SUB"*)
echo -n "Exists!"
;;
esac
Usando el operador Regex
Otra opción para determinar si una subcadena especificada ocurre dentro de una cadena es usar el operador regex = ~. Cuando se utiliza este operador, la cadena correcta se trata como una expresión regular.
El punto seguido de un asterisco . * Coincide con cero o más ocurrencias de cualquier carácter excepto un carácter de nueva línea.
#!/bin/bash
STR='GNU/Linux is an operating system'
SUB='Linux'
if [[ "$STR" =~.*"$SUB".* ]]; then
echo "Exists!"
fi
El script devolverá el siguiente mensaje:
Exists!
Usando Grep
El comando grep también se puede utilizar para buscar cadenas en otra cadena.
En el siguiente ejemplo, estamos pasando la cadena $ STR como entrada a grep y comprobando si la cadena $ SUB está dentro de la cadena de entrada. El comando devolverá verdadero o falso.
#!/bin/bash
STR='GNU/Linux is an operating system'
SUB='Linux'
if grep -q "$SUB" <<< "$STR"; then
echo "Exists!"
fi
La opción -q le dice a grep que omita la salida.

32
Linux/cambiar permisos a directorios y ficheros independientemente.txt Normal file
View File

@ -0,0 +1,32 @@
Cambiar permisos recursivamente solo a directorios:
find . -type d -exec chmod -R 0755 {} \;
Cambiar permisos recursivamente solo a archivos:
find . -type f -exec chmod -R 0644 {} \;
El punto (.) puede ser cambiado por alguna ruta absoluta, por ejemplo /home/miusuario/midirectorio/.
Cambiar permisos solo a los Directorios
En Linux, algunas veces necesitamos cambiar permisos solamente a los directorios y no a los archivos comunes.
Para esto podemos usar el comando find:
find . -type d -exec chmod 755 \{\} \;
Esto lo que hace es cambiarle los permisos a todos los directorios de donde nos encontremos parados.
Cambiar permisos solo a los Archivos
En Linux, algunas veces necesitamos cambiar permisos solamente a los archivos y no a los directorios comunes.
Para esto podemos usar el comando find:
find . -type f -print0 | xargs -0 chmod 644;
Esto lo que hace es cambiarle los permisos a todos los archivos del directorio donde nos encontremos parados y de los subdirectorios.
Cambiar permisos a todos los Directorios y Archivos
Una opción común cuando se desea cambiar todo un árbol de directorios, es decir, varios directorios anidados y sus archivos correspondientes, es usar la opción -R, de recursividad:
chmod -R 644 directorio/*;
Esto cambiará los permisos a 644 (rwxr-xr-x) del directorio respaldos y de todos los subdirectorios y archivos que estén contenidos dentro de este.

9
Linux/capturar todos los registros de errores PHP en un archivo.txt Normal file
View File

@ -0,0 +1,9 @@
Capturar todos los registros de errores PHP en un archivo
sudo nano /etc/php.ini
error_log = "/var/log/php_errors.log"
log_errors = On
display_errors = Off
sudo touch /var/log/php_errors.log
sudo chown www-data:www-data /var/log/php_errors.log

23
Linux/chmods habituales.txt Normal file
View File

@ -0,0 +1,23 @@
Permisos en Linux: chmod 777, chmod 644, chmod 755, chmod 700, chmod 666
Los tipos de permisos más comunes, o su combinación, son los siguiente:
666 ( RW / RW / RW)
Esta opción permite que todos los usuarios puedan leer y escribir en un archivo.
777 ( RWX / RWX /RWX)
Esta opción permite que todos los usuarios puedan leer, escribir y ejecutar en el archivo o carpeta
755 (RWX / RW / RW)
Con este permiso el propietario del archivo puede leer, escribir y ejecutar en el archivo mientras que los demás leer y escribir en el archivo mas no ejecutar.
644 (RW / R / R)
Con este permiso el propietario puede leer y escribir en el archivo mientras los demás solo pueden leer.
700 (RWX /---)
Con este permiso el propietario tiene el control total del archivo mientras que los demás usuarios no tendrán acceso de ningún tipo al archivo.
CALCULADORA CHMOD:
https://chmod-calculator.com/

9
Linux/cifrar home existente.txt Normal file
View File

@ -0,0 +1,9 @@
apt-get update
apt-get install ecryptfs-utils
reboot
[Ctrl+Alt+F1] > login root
ecryptfs-migrate-home -u usuario
[Ctrl+Alt+F7] > login usuario
ecryptfs-unwrap-passphrase
sudo rm -rf /home/usuario.xxxxxxx

11
Linux/conectarse ssh con claves rsa-dsa.txt Normal file
View File

@ -0,0 +1,11 @@
ssh-keygen -b 4096
scp .ssh/id_rsa.pub usuario@maquina:/tmp
ssh usuario@maquina
cat /tmp/id_rsa.pub >> .ssh/authorized_keys
rm /tmp/id_rsa.pub
sudo nano /etc/ssh/sshd_config
*** las lineas siguientes sin comentar:
RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys
sudo /etc/init.d/ssh restart

59
Linux/configuracion de NGinx en HA.txt Normal file
View File

@ -0,0 +1,59 @@
Configuracion de NGinx en HA
Instalación del sistema
Partimos de la instalación del sistema propuesta en el siguiente enlace Instalación Nginx/1.6.2 (stable) en Centos7
Para nuestro ejemplo trabajaremos con dos servidores Centos 7 llamados "app01-local" con IP 10.32.20.62, "app02-local" con IP 10.32.20.60, asignaremos una IP virtual para el cluster que será la 10.32.20.254, y al cluster le llamaremos "cluster-web"
Para poder trabajar con el nombre de las maquinas tendremos que añadirlos a "/etc/hosts"
10.32.20.62 app01-local
10.32.20.60 app02-local
Instalación de paquetes necesarios en ambos nodos, creación de usuario "hacluster" y arranque del servicio.
sudo yum install corosync pcs pacemaker
sudo passwd hacluster (Contraseña del usuario del hacluster)
sudo systemctl start pcsd (arrancar servicio)
Pasos a realizar solo desde uno de los nodos
sudo pcs cluster auth app01-local app02-local (autenticamos los nodos para el cluster, cuando pregunte introduciremos el usuario del creado anteriormente para el cluster y su password)
sudo pcs cluster setup --name cluster_web app01-local app02-local (añadimos los nodos al cluster)
sudo pcs cluster start --all (arrancamos los servicios de cluster de los nodos)
sudo pcs status cluster (vemos el estado de los cluster)
sudo pcs status nodes (vemos el estado de los nodos)
sudo corosync-cmapctl | grep members
sudo pcs status corosync
--Chequeo de errores del cluster
sudo crm_verify -L -V (veremos un error referente a "stonith" que solucionamos en el siguiente paso)
sudo pcs property set stonith-enabled=false (soluciona el error que nos ha aparecido)
sudo pcs property set no-quorum-policy=ignore (Ignoramos el quorum)
sudo pcs property (comprobamos que todo es correcto)
Configruación de la IP virtual
sudo pcs resource create virtual_ip ocf:heartbeat:IPaddr2 ip=10.32.20.254 cidr_netmask=32 op monitor interval=30s
sudo pcs status resources (comprobamos el estado de la ip virtual)
Detenemos el servicio de Nginx en ambos nodos
sudo systemctl stop nginx
Continuamos trabajando sobre el primer nodo que habiamos elegido
sudo pcs resource create webserver ocf:heartbeat:nginx configfile=/etc/nginx/conf.d/default.conf
statusurl="http://localhost/server-status" op monitor interval=1min --force
sudo pcs constraint colocation add webserver virtual_ip INFINITY
sudo pcs constraint order virtual_ip then webserver
sudo pcs constraint location webserver prefers app01-local=50
--Reinicio del cluster
sudo pcs cluster stop --all && sudo pcs cluster start --all
Pasamos todos los servicios necesarios a "enable" en ambos nodos.
sudo systemctl enable pcsd
sudo systemctl enable corosync
sudo systemctl enable pacemaker
sudo systemctl enable nginx
Añadimos lo siguiente en "/etc/nginx/nginx.conf" en ambos servidores
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
upstream wwwapp01 {
server app01-local;
server app02-local;
}

146
Linux/configuración de un cluster (Corosync y Pacemaker) en un servidor Ubuntu 20.04.txt Normal file
View File

@ -0,0 +1,146 @@
Configuración de un cluster (Corosync y Pacemaker) en un servidor Ubuntu 20.04
La instalación funciona con Pacemaker 2.0.3, pcs en la versión 0.10.4 y Corosync crm 4.0.0
Con la versión 0.9.x de PCS y anteriores, la sintaxis es diferente en algunos lugares. Aquí recomiendo las siguientes instrucciones
Estoy en una red local (Fritzbox) y tengo las Ips 192.168.188.110 y 192.168.188.111 para los nodos. 192.168.188.112 se utilizó para la IP flotante utilizada posteriormente. Uso dos VMs bajo VMWare Workstation 16 y Remmina como terminal para un mejor acceso. Mi propio ordenador tiene la IP 192.168.188.81. Todos los comandos se ejecutan en ambos nodos (VMs) al principio.
En ambas VM (nodos) haga las siguientes entradas en /etc/hosts
192.168.188.110 node1.example.com
192.168.188.111 node2.example.com
Los archivos se ven así para mí
cat /etc/hosts
Output
127.0.0.1 localhost
127.0.1.1 ubuntu-server
192.168.188.110 node1.example.com
192.168.188.111 node2.example.com
# The following lines are desirable for IPv6 capable hosts
::1 ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
Instalar Nginx como servidor web, Corosync y Pacemaker
apt install nginx
apt install corosync pacemaker pcs
Activar e iniciar Nginx
systemctl enable nginx;
systemctl start nginx;
Cambia la página Nginx por defecto en cada nodo para que puedas ver dónde estás.
en el nodo1
echo "This is the default page for node1.example.com" | sudo tee /var/www/html/index.nginx-debian.html
y en el nodo2
echo "This is the default page for node2.example.com" | sudo tee /var/www/html/index.nginx-debian.html
como estamos en un servidor Ubuntu, el firewall ufw está habilitado allí y necesitamos crear recursos compartidos en ambos nodos.
ufw allow from 192.168.188.81 to any
ufw allow from 192.168.188.111 to any (only node 1)
ufw allow from 192.168.188.110 to any (only node 2)
Activar y poner en marcha el marcapasos
systemctl enable pcsd
systemctl start pcsd
Con la instalación, se creó un usuario "hacluster", que sigue necesitando una contraseña.
passwd hacluster
New password: dasPasswort
Retype new password: dasPasswort
Hasta ahora, todos los comandos se ejecutaban en ambos nodos. Ahora sólo en el nodo1
pcs cluster auth
Output
Warning: Unable to read the known-hosts file: No such file or directory: '/var/lib/pcsd/known-hosts'
node1: Not authorized
Nodes to authorize: node1
Username: hacluster
Password: dasPasswort
node1: Authorized
ahora autenticar los nodos
pcs host auth node1.example.com node2.example.com
Output
Username: hacluster
Password: dasPasswort
node1.example.com: Authorized
node2.example.com: Authorized
pcs cluster setup cluster1 node1.example.com node2.example.com --force
Output
No addresses specified for host 'node1.example.com', using 'node1.example.com'
No addresses specified for host 'node2.example.com', using 'node2.example.com'
Warning: node1.example.com: Running cluster services: 'corosync', 'pacemaker', the host seems to be in a cluster already
Warning: node1.example.com: Cluster configuration files found, the host seems to be in a cluster already
Warning: node2.example.com: Running cluster services: 'corosync', 'pacemaker', the host seems to be in a cluster already
Warning: node2.example.com: Cluster configuration files found, the host seems to be in a cluster already
Destroying cluster on hosts: 'node1.example.com', 'node2.example.com'...
node2.example.com: Successfully destroyed cluster
node1.example.com: Successfully destroyed cluster
Requesting remove 'pcsd settings' from 'node1.example.com', 'node2.example.com'
node2.example.com: successful removal of the file 'pcsd settings'
node1.example.com: successful removal of the file 'pcsd settings'
Sending 'corosync authkey', 'pacemaker authkey' to 'node1.example.com', 'node2.example.com'
node1.example.com: successful distribution of the file 'corosync authkey'
node1.example.com: successful distribution of the file 'pacemaker authkey'
node2.example.com: successful distribution of the file 'corosync authkey'
node2.example.com: successful distribution of the file 'pacemaker authkey'
Sending 'corosync.conf' to 'node1.example.com', 'node2.example.com'
node1.example.com: successful distribution of the file 'corosync.conf'
node2.example.com: successful distribution of the file 'corosync.conf'
Cluster has been successfully set up.
pcs cluster enable --all
Output
node1.example.com: Cluster Enabled
node2.example.com: Cluster Enabled
pcs cluster start --all
Output
node1.example.com: Starting Cluster...
node2.example.com: Starting Cluster...
Desactivar las segundas propiedades
pcs property set stonith-enabled=false
pcs property set no-quorum-policy=ignore
Especifique la IP flotante indicada anteriormente bajo la cual se podrá acceder al clúster más adelante
pcs resource create floating_ip ocf:heartbeat:IPaddr2 ip=192.168.188.112 cidr_netmask=24 op monitor interval=60s
Hay que comprobar qué nodo está activo y, si es necesario, hay que desplazarlo
pcs resource create http_server ocf:heartbeat:nginx configfile="/etc/nginx/nginx.conf" op monitor timeout="20s" interval="60s"
Tenemos la salida de estado
pcs status resources
Output
root@ubuntu-server:/home/bernd# pcs status resources
* Resource Group: cluster1:
* floating_ip (ocf::heartbeat:IPaddr2): Started node1.example.com
* http_server (ocf::heartbeat:nginx): Started node2.example.com
Aquí puedes ver que todo está funcionando, pero desafortunadamente en diferentes nodos. Tenemos que agrupar todo
crm configure group cluster1 floating_ip http_server
Aparece un mensaje de error (para mí), pero lo ignoro.
Output
ERROR: (unpack_config) warning: Blind faith: not fencing unseen nodes
Vuelvo a tener el estado mostrado y veo
pcs status resources
Output
root@ubuntu-server:/home/bernd# pcs status resources
* Resource Group: cluster1:
* floating_ip (ocf::heartbeat:IPaddr2): Started node1.example.com
* http_server (ocf::heartbeat:nginx): Started node1.example.com
Todo se ejecuta en el nodo1 como se desea. Ahora llamo a la interfaz web para seguir trabajando allí. Esto debe hacerse con https, incluso si no se almacena ningún certificado. Por lo tanto, aparece una advertencia en el navegador, que acepto.
https://192.168.188.112:2224/manage
Iniciar sesión con hacluster y la contraseña +Añadir salida en el campo que aparece, introduzca "nodo1.ejemplo.com" sin "" y luego el botón "Añadir salida". Luego hay que esperar un poco hasta que se cargue todo. En el sitio de la izquierda puede hacer clic en "cluster1". Entonces, espera un poco más. Ahora puedes ver ambos nodos.
https://cdn3.adminscout.net/configuration/bff4bd9f896293d5f838a5c178288a3e.png
En el navegador, al introducir http://192.168.188.112/, aparece lo siguiente
https://cdn3.adminscout.net/configuration/58d5f7de45fbce7b2eacad6a5124b0ec.png
Si ahora cambias el nodo1 a standby en la interfaz del Web Admin, puedes ver que cambia al nodo2, como puedes ver en las siguientes imágenes
https://cdn3.adminscout.net/configuration/9d18c9145f1a8cc7dd958c9db8d9dd73.png
https://cdn3.adminscout.net/configuration/d2ecba400b47aa21c38d11756c65b0fd.png

BIN
Linux/configurar arreglo RAID1 durante la instalacion de Ubuntu Server.docx Normal file
View File

Binary file not shown.

75
Linux/configurar red en CentOS.txt Normal file
View File

@ -0,0 +1,75 @@
=== COMPROBAR ESTADO DE LA INTERFAZ ===
-- con el comando ip
Vamos a comprobar el estado de las interfaces de red en CentOS, con
ip link show
o también, para mostrar la info de todas las interfaces:
ip a
o
ip addr
-- con el comando nmcli
También podemos usar nmcli para comprobar el estado de las interfaces de red en CentOS.
Con el comando nmcli podemos listar las interfaces disponibles y su status
nmcli device status
o
nmcli connection show
=== CONFIGURAR LOS ARCHIVOS CORRESPONDIENTES A LAS INTERFACES DE RED EN CENTOS 7 ===
Una vez comprobado el estado de las interfaces de red, vamos a conectar alguna de las interfaces a la red.
editamos el archivo
/etc/sysconfig/network-scripts/ifcfg-enp0s3
Y comprobamos que la interfaz está configurada para que NO se inicie con cada arranque (ONBOOT=no)
Así que lo vamos a cambiar para que la interfaz pueda iniciarse (ONBOOT=yes)
(Ahora usaremos DHCP, pero si quisiéramos configurar una ip estática, cambiaremos también BOOTPROTO=dhcp por BOOTPROTO=static). Más adelante se muestra cómo configurar la dirección estática.
Reiniciar el servicio de red en CentOS
Ahora que ya hemos activado la interfaz de red enp0s3 para que se inicie en cada arranque de la máquina, vamos a reiniciar el servicio de red para aplicar los cambios de red en CentOS:
systemctl restart network.service
o
systemctl restart network
Comprobar que nuestras interfaces de red en CentOS están activas y que ya tenemos dirección de red
ip a
comprobar direccion de red de las interfaces
Y comprobamos la ruta con ip route, veremos que ya tenemos IP y una ruta, que sale por la interfaz enp0s3:
ip r
comprobar las rutas con ip route
--Configurar manualmente las interfaces de red
Como hemos visto antes, la interfaz de red ya está activa, pero está funcionando con DHCP. Nos interesa configurar la interfaz de red de forma manual en CentOS.
Modificaremos al menos las siguientes opciones en el archivo de configuración de la interfaz de red:
BOOTPROTO : define el tipo de configuración que tiene la interfaz. Puede ser dhcp, none o static.
ONBOOT : Define si la interfaz se activa en el arranque
IPADDR0 : La primera dirección de la interfaz (podemos configurar varias).
PREFIX0 : el prefijo de la red (lo que antes se llamaba Netmask, la máscara de red).
GATEWAY0: La puerta de enlace (también puede haber varias).
DNS1: El servidor DNS
De forma que nuestro archivo /etc/sysconfig/network-scripts/ifcfg-enp0s3 queda así finalmente:
TYPE=Ethernet
PROXY_METHOD=none
BROWSER_ONLY=no
#BOOTPROTO=dhcp
BOOTPROTO=none
DEFROUTE=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=yes
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_FAILURE_FATAL=no
IPV6_ADDR_GEN_MODE=stable-privacy
NAME=enp0s3
UUID=7bcec556-cd84-4a0e-9834-ca7615a83722
DEVICE=enp0s3
ONBOOT=yes
ipaddr0=192.168.8.113
PREFIX0=24
GATEWAY=192.168.8.1
DNS1=8.8.8.8

32
Linux/connect to ubuntu phone over ssh.txt Normal file
View File

@ -0,0 +1,32 @@
To activate ssh access entirely over wifi, without developer mode on the phone, without any special tooling on your computer and without using USB:
If you don't already have an ssh keypair, type ssh-keygen on your computer and follow the instructions to generate one.
Install the Terminal app on the phone from the App Store.
Open a Terminal and type (this is easier with the phone in a landscape orientation):
sudo setprop persist.service.ssh true
mkdir -pm700 ~/.ssh
ip addr
nc -l 1234 > ~/.ssh/authorized_keys
(the last command will hang; this is expected)
Look for your phone's IP address in the Terminal as returned by the ip addr command above.
On your computer, type (replacing 192.0.2.1 with your phone's IP address from above):
nc 192.0.2.1 1234 < ~/.ssh/id_rsa.pub
If successful, the last command on your phone's Terminal will now succeed.
On your computer, type (again replacing 192.0.2.1 with your phone's IP address from above):
ssh phablet@192.0.2.1
If your phone's IP address changes, you will need to use ip addr in the Terminal app on your phone again and adjust your ssh command accordingly.

125
Linux/creando un router en Debian.txt Normal file
View File

@ -0,0 +1,125 @@
Es necesario que el servidor Debian tenga dos tarjetas de red. Vamos a llamarlas eth0 y eth1, siguiendo la denominación convencional. La interfaz eth0 se conecta a Internet mientras que eth1 se conecta al router inalámbrico (Access Point).
Antes de continuar, debemos ingresar a la interfaz de administración del router inalámbrico y anotar la sub-red que utiliza. Vamos a suponer que es 192.168.1.0/24.
La conexión a Internet es generalmente de tipo Banda Ancha, mediante un cable modem. En este caso, el cable módem se encarga de adquirir un número IP del proveedor a través de DHCP y el servidor Debian simplemente lo agarra como suyo. Edita /etc/network/interfaces y define eth0 como DHCP,
# The primary network interface
auto eth0
iface eth0 inet dhcp
Conecta eth0 al módem con un cable de red ("twisted pair"), luego reinicia el módem y el computador Debian. Prueba conexiones Internet. El comando,
# ifconfig eth0
debería retornar los parámetros de red asignados.
Alternativa, la conexión a Internet es de tipo ADSL, en cuyo caso se requiere PPPoE. Sigue las instrucciones de la guía http://man-es.debianchile.org/adsl.html
Edita /etc/network/interfaces y define eth1 como una sub-red estática privada,
auto eth1
iface eth1 inet static
address 192.168.0.1
netmask 255.255.255.0
network 192.168.0.0
broadcast 192.168.0.255
Es muy importante que esta definición no contenga una pasarela (gateway). Es igualmente importante que esta sub-red sea diferente a la sub-red del router inalámbrico, esta siendo 192.168.0.0/24 mientras que la del router inalámbrico 192.168.1.0/24.
Levanta la interfaz eth1 con,
# ifup eth1
'ifconfig eth1' debería retornar los parámetros de red recién asignados.
Conecta eth1 al router inalámbrico con un cable de red ("twisted pair") al mismo puerto que antes estaba conectado a Internet.
Vamos a suponer que el router inalámbrico estaba configurado para adquirir valores de red WAN vía DHCP. Como ahora está conectado al servidor Debian, necesitamos reconfigurarlo en una red estática, con valores,
IP Address : 192.168.0.2
Subnet Mask : 255.255.255.0
Default Gateway : 192.168.0.1
Primary DNS Server : 192.168.0.1
La pasarela (gateway) debe ser el número IP del servidor Debian.
Si no es posible definir una red estática, debido a que el router inalámbrico no permite la opción de red más que con DHCP, es necesario instalar y configurar el servidor DHCP en el servidor Debian. Instala isc-dhcp-server,
# apt-get install isc-dhcp-server
Edita /etc/default/isc-dhcp-server y modifica la variable INTERFACES con,
INTERFACES="eth1"
Edita /etc/dhcp/dhcpd.conf. Descomenta el instructivo "authoritative",
authoritative;
y define una sub-red,
subnet 192.168.0.0 netmask 255.255.255.0 {
range 192.168.0.2 192.168.0.2;
option routers 192.168.0.1;
option ip-forwarding off;
option broadcast-address 192.168.0.255;
option subnet-mask 255.255.255.0;
option domain-name-servers 192.168.0.1;
default-lease-time 86400;
max-lease-time 86400;
}
Esta definición va a servir un solo IP; 192.168.0.2. Observa /var/log/syslog en un terminal con,
$ tail -f /var/log/syslog
luego reinicia en otro terminal el servidor DHCP,
# /etc/init.d/isc-dhcp-server restart
Observa en /var/log/syslog como el router inalámbrico automáticamente adquiere un IP,
May 30 20:27:01 debian dhcpd: DHCPDISCOVER from 00:24:b2:28:8e:f7 via eth1
May 30 20:27:01 debian dhcpd: icmp_echorequest 192.168.0.2: Operation not permitted
May 30 20:27:02 debian dhcpd: DHCPOFFER on 192.168.0.2 to 00:24:b2:28:8e:f7 via eth1
May 30 20:27:05 debian dhcpd: DHCPREQUEST for 192.168.0.2 (192.168.0.1) from 00:24:b2:28:8e:f7 via eth1
May 30 20:27:05 debian dhcpd: DHCPACK on 192.168.0.2 to 00:24:b2:28:8e:f7 via eth1
El router inalámbrico tiene dirección Internet 192.168.0.2, pasarela y servidor DNS 192.168.0.1.
Necesitamos instalar y configurar el servidor DNS. Instala bind9,
# apt-get install bind9
Edita el archivo /etc/bind/named.conf.options y modifica el instructivo forwarders con las direcciones IP de los DNS del proveedor de Internet,
forwarders {
100.10.0.3;
100.10.0.7;
};
Para obtener las direcciones IP del DNS inspecciona el archivo /etc/resolv.conf. Este fue escrito automáticamente con los valores retornados por el servidor DHCP del proveedor.
Ahora edita /etc/resolv.conf para que lea,
nameserver 127.0.0.1
Remueve los instructivos "domain" y "search" si existen y los antiguos forwarders.
Reinicia el servidor DNS,
# /etc/init.d/bind9 restart
para que los cambios tomen efecto.
Esto transforma a localhost en servidor DNS, que vía BIND9 resuelve nombres haciendo requerimientos a los DNS del proveedor. En particular, 192.168.0.1 también es un servidor DNS.
Falta un pequeño detalle. Cada vez que el "lease" del servidor DHCP del proveedor se renueva, este reenvía los valores con que /etc/resolv.conf se reescribe automáticamente. Para evitar esto y de hecho borrar la nueva configuración, remueve la atribución de escritura sobre el archivo,
chattr +i /etc/resolv.conf
Falta redirigir eth1 a eth0 para que la red interna 192.168.1.0/24 del router inalámbrico pueda salir a Internet. Aquí debemos hacer dos cosas: 1) redirigir eth1 a eth0 y 2) reescribir los números IP 192.168.1.x con el número IP público del servidor Debian. Esto se llama enmascarar. Si no se enmascara, los paquetes de red salientes de la red interna tendrian IP 192.168.1.x y serían bloqueados ("IP spoofing").
En Debian, redirigir no es una opción por omisión. Para activarlo hay que modificar el valor de /proc/sys/net/ipv4/ip_forward de 0 a 1.
# echo 1 > /proc/sys/net/ipv4/ip_forward
Un,
$ cat /proc/sys/net/ipv4/ip_forward
debería retornar 1.
Falta otro pequeño detalle. Al reiniciar el computador, se reescribe /proc/sys/net/ipv4/ip_forward con el valor por omisión, que es 0, deshabilitando la redirección. Para evitar esto, edita /etc/sysctl.conf y descomenta,
net.ipv4.ip_forward=1
Ahora el valor de /proc/sys/net/ipv4/ip_forward se reescribe a 1.
En este punto puede ser ventajoso entrar a la administración del router inalámbrico, quizás con otro computador de la sub-red 192.168.1.0/24, y activar la administración remota desde la IP 192.168.0.1.
Ahora hay que activar el enrutamiento enmascarando las IP con iptables:
// Haciendo NAT en el servidor
sudo iptables -A FORWARD -j ACCEPT
sudo iptables -t nat -A POSTROUTING -s 192.0.0.0/8 -o eth0 -j MASQUERADE
// Esto viene a decir que cojo toda la red privada y permito que salga por el interfaz publico

39
Linux/crear fichero swap en linux.txt Normal file
View File

@ -0,0 +1,39 @@
************RESUMEN***************
dd if=/dev/zero of=/swapfile bs=1024 count=1024k
mkswap /swapfile
swapon /swapfile
swapon -s
echo '/swapfile swap swap defaults 0 0' >> /etc/fstab
**************************************
Utilizar un archivo como memoria de intercambio.
Este método no requiere hacer cambios en la tabla de particiones del disco duro. Ideal para usuarios poco experimentados, para quienes desean evitar tomar riesgos al cambiar la tabla de particiones de su disco duro, o bien para quienes requieren más de memoria de intercambio ocasional, o de manera circunstancial.
Considerando que el archivo de memoria de intercambio puede ser colocado en cualquier directorio del disco duro, se ejecuta el comando dd, especificando que se escribirán ceros (if=/dev/zero) para crear el archivo /swap (of=/swap), en bloques de 1024 bytes (bs=1024) hasta completar una cantidad en bytes determinada (count=[cantidad multiplicada por el valor de bs]).
En el siguiente ejemplo se realiza lo anterior hasta completar 524288000 bytes (dividido por 1024 equivalen a 512 MB)
Para crear el archivo que utilizaremos como SWAP abriremos una consola y escribiremos lo siguiente (como root):
dd if=/dev/zero of=/swap bs=1024 count=512000
El paso anterior puede demorar unos segundos, tenga paciencia. Luego, para dar formato de memoria de intercambio al archivo creado, ejecutaremos el comando mkswap, del siguiente modo (siempre como root):
mkswap /swap
Se le devolverá una salida en la consola similar a lo siguiente:
Setting up swapspace version 1, size = 511996 KiB
no label, UUID=fed2aba5-77c6-4780-9a78-4ae5e19c506b
Para activar la partición, y que sea utilizada inmediatamente por el sistema operativo, se ejecuta el comando swapon. En nuestro caso activaremos como partición de memoria de intercambio al archivo /swap que creamos y dimos formato SWAP en los pasos anteriores:
swapon /swap
Para verificar que el nuevo archivo de memoria de intercambio está siendo utilizada por el sistema operativo, ejecutaremos nuevamente el comando free y veremos que se le ha sumado a la memoria SWAP inicial la capacidad del nuevo archivo.
Para que este archivo se utilice como memoria de intercambio automáticamente en el siguiente arranque del sistema, editaremos /etc/fstab (utilizando nano, gedit, kate, kwrite, vim o el editor de texto plano de su preferencia), agregando la línea correspondiente, del siguiente modo, donde en lugar de el dispositivo, se pone la ruta del archivo de memoria de intercambio creado:
Abrimos el archivo
nano /etc/fstab
Y le añadimos:
/swap swap swap defaults 0 0
Listo!!!!
Podemos reiniciar el sistema y probar que nuestra memoria de intercambio se ha incrementado con el uso del nuevo archivo SWAP. Sencillamente lo que hemos hecho es crear un archivo en la raíz del sistema, darle formato SWAP y decirle a nuestro GNU/Linux que lo utilice como memoria de intercambio, junto a la partición que ya teníamos destinada para este objetivo.
Algo sencillo pero que pudiera ser de cierta utilidad a muchos de nosotros… Sin más…

301
Linux/crear un certificado SSL autofirmado para Apache en Ubuntu.txt Normal file
View File

@ -0,0 +1,301 @@
Cómo crear un certificado SSL autofirmado para Apache en Ubuntu 18.04
Justin Ellingwood escribió una versión anterior de este tutorial.
Introducción
La TLS, o seguridad en la capa de transporte, y la SSL, plataforma antecesora cuya sigla significa “capa de sockets seguros”, son protocolos web que se utilizan para envolver el tráfico normal con una cobertura protegida cifrada.
Mediante esta tecnología, los servidores pueden enviar tráfico de forma segura entre servidores y clientes sin la posibilidad de que los mensajes sean interceptados por terceros. El sistema de certificado también ayuda a los usuarios a verificar la identidad de los sitios con los que establecen conexión.
En esta guía, le mostraremos la manera de configurar un certificado SSL autofirmado para su uso con un servidor web de Apache en Ubuntu 18.04.
Nota: Un certificado autofirmado cifrará la comunicación entre su servidor y cualquier cliente. Sin embargo, dado que no está firmado por ninguna de las autoridades certificadoras de confianza incluidas con los navegadores web, los usuarios no pueden usar el certificado para validar la identidad de su servidor de forma automática.
Es posible que un certificado autofirmado sea apropiado si no dispone de un nombre de dominio asociado con su servidor y para casos en los que una interfaz web cifrada no esté dirigida al usuario. Si dispone de un nombre de dominio, en muchos casos es mejor usar un certificado firmado por una autoridad certificadora (CA). Puede averiguar la manera de configurar un certificado de confianza gratuito a través del proyecto Let´s Encrypt aquí.
Requisitos previos
Antes de comenzar, deberá contar con un usuario no root configurado con privilegios sudo. Puede aprender a configurar una cuenta de usuario de este tipo siguiendo nuestra Configuración inicial de servidores con Ubuntu 18.04.
También deberá tener instalado el servidor web de Apache. Si desea instalar una pila LAMP completa (Linux, Apache, MySQL y PHP) en su servidor, puede seguir nuestra guía de configuración de LAMP en Ubuntu 18.04. Si solo quiere el servidor web de Apache, omita los pasos correspondientes a PHP y MySQL.
Una vez que cumpla con los requisitos previos, siga los pasos que se muestran a continuación.
Paso 1: Crear el certificado SSL
La TLS y la SSL funcionan utilizando una combinación de un certificado público y una clave privada. La clave SSL se mantiene secreta en el servidor. Se utiliza para cifrar contenido que se envía a los clientes. El certificado SSL se comparte de forma pública con cualquiera que solicite el contenido. Puede utilizarse para descifrar el contenido firmado por la clave SSL asociada.
Podemos crear un par de clave y certificado autofirmados con OpenSSL en un único comando:
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/apache-selfsigned.key -out /etc/ssl/certs/apache-selfsigned.crt
Se le harán varias preguntas. Antes de abordar eso, observemos lo que sucede en el comando que emitimos:
openssl: es la herramienta de línea de comandos básica para crear y administrar certificados, claves, y otros archivos de OpenSSL.
req: este subcomando especifica que deseamos usar la administración de la solicitud de firma de certificados (CSR) X.509. El “X.509” es un estándar de infraestructura de claves públicas al que se adecuan SSL y TLS para la administración de claves y certificados a través de él. Queremos crear un nuevo certificado X.509, por lo que usaremos este subcomando.
-x509: modifica aún más el subcomando anterior al indicar a la utilidad que deseamos crear un certificado autofirmado en lugar de generar una solicitud de firma de certificados, como normalmente sucede.
-nodes: indica a OpenSSL que omita la opción para proteger nuestro certificado con una frase de contraseña. Necesitamos que Apache pueda leer el archivo, sin intervención del usuario, cuando se inicie el servidor. Una frase de contraseña evitaría que esto suceda porque tendríamos que ingresarla tras cada reinicio.
-days 365: esta opción establece el tiempo durante el cual el certificado se considerará válido. En este caso, lo configuramos por un año.
-newkey rsa:2048: especifica que deseamos generar un nuevo certificado y una nueva clave al mismo tiempo. No creamos la clave que se requiere para firmar el certificado en un paso anterior, por lo que debemos crearla junto con el certificado. La parte rsa:2048 le indica que cree una clave RSA de 2048 bits de extensión.
-keyout: esta línea indica a OpenSSL dónde colocar el archivo de clave privada generado que estamos creando.
-out: indica a OpenSSL dónde colocar el certificado que creamos.
Como se mencionó anteriormente, estas opciones crearán un archivo de clave y un certificado. Se harán algunas preguntas sobre nuestro servidor con el fin de insertar la información de forma correcta en el certificado.
Complete las solicitudes de forma adecuada. La línea más importante es aquella en la que se solicita Common Name (e.g. server FQDN or YOUR name). Debe ingresar el nombre de dominio asociado con su servidor o, lo más probable, la dirección IP pública de su servidor.
La totalidad de las solicitudes tendrán un aspecto similar a este:
Output
Country Name (2 letter code) [AU]:US
State or Province Name (full name) [Some-State]:New York
Locality Name (eg, city) []:New York City
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Bouncy Castles, Inc.
Organizational Unit Name (eg, section) []:Ministry of Water Slides
Common Name (e.g. server FQDN or YOUR name) []:server_IP_address
Email Address []:admin@your_domain.com
Los dos archivos que creó se ubicarán en los subdirectorios correspondientes en /etc/ssl.
Paso 2: Configurar Apache para usar SSL
Hemos creado nuestros archivos de clave y certificado en el directorio /etc/ssl. Ahora solo debemos modificar nuestra configuración de Apache para aprovecharlos.
Aplicaremos algunos ajustes a nuestra configuración:
Crearemos un fragmento de configuración para especificar configuraciones SSL seguras predeterminadas.
Modificaremos el archivo de host virtual de Apache SSL incluido para apuntar a los certificados SSL que generamos.
(Recomendado) Modificaremos el archivo de host virtual no cifrado para redireccionar las solicitudes de forma automática al host virtual cifrado.
Al terminar, deberíamos contar con una configuración SSL segura.
Crear un fragmento de configuración de Apache con ajustes de cifrado seguro
Primero, crearemos un fragmento de configuración de Apache para definir algunos ajustes de SSL. Con esto, se configurará Apache con un conjunto de cifrado SSL seguro y se habilitarán algunas características avanzadas que ayudarán a mantener protegido nuestro servidor. Los parámetros que configuraremos pueden utilizarse a través de cualquier hosting virtual que habilite SSL.
Cree un nuevo fragmento en el directorio /etc/apache2/conf-available. Daremos el nombre ssl-params.conf al archivo para que quede claro su propósito:
sudo nano /etc/apache2/conf-available/ssl-params.conf
Para configurar Apache SSL de forma segura, usaremos las recomendaciones que Remy van Elst da en el sitio de Cipherli.st. Este sitio está diseñado para proporcionar configuraciones de cifrado fáciles de utilizar para software popular.
Las configuraciones propuestas en el sitio del vínculo anterior ofrecen una seguridad confiable. A veces, esto se hace a costa de una mayor compatibilidad con el cliente. Si necesita ofrecer compatibilidad con clientes anteriores, existe una lista alternativa a la que se puede acceder haciendo clic en el enlace de la página con la etiqueta “Sí, quiero un conjunto de cifrado que funcione con el software anterior o heredado”. Esa lista puede sustituirse por los elementos copiados a continuación.
La elección de la configuración que utilizará dependerá en gran medida de aquello para lo que deba ofrecer compatibilidad. Ambas opciones proporcionarán una gran seguridad.
Para nuestros propósitos, podemos copiar las configuraciones proporcionadas en su totalidad. Sólo haremos un pequeño cambio. Deshabilitaremos el encabezado Strict-Transport-Security (HSTS).
La precarga del HSTS proporciona una mayor seguridad, pero puede tener consecuencias importantes si se habilita accidentalmente o de forma incorrecta. En esta guía, no habilitaremos las configuraciones, pero puede aplicar una modificación si está seguro de comprender las implicaciones.
Antes de tomar una decisión, tómese un momento para informarse sobre seguridad estricta de transporte de HTTP, o HSTS, y en particular sobre la funcionalidad “preload”.
Pegue la configuración en el archivo ssl-params.conf que abrimos:
/etc/apache2/conf-available/ssl-params.conf
SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1
SSLHonorCipherOrder On
# Disable preloading HSTS for now. You can use the commented out header line that includes
# the "preload" directive if you understand the implications.
# Header always set Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
Header always set X-Frame-Options DENY
Header always set X-Content-Type-Options nosniff
# Requires Apache >= 2.4
SSLCompression off
SSLUseStapling on
SSLStaplingCache "shmcb:logs/stapling-cache(150000)"
# Requires Apache >= 2.4.11
SSLSessionTickets Off
Guarde y cierre el archivo cuando haya terminado.
Modificar el archivo de host virtual de Apache SSL predeterminado
A continuación, modificaremos /etc/apache2/sites-available/default-ssl.conf, el archivo de host virtual de SSL predeterminado. Si usa un archivo de bloque de servidor diferente, sustituya su nombre en los comandos que se muestran a continuación.
Antes de continuar, realizaremos una copia de seguridad del archivo original de host virtual de SSL:
sudo cp /etc/apache2/sites-available/default-ssl.conf /etc/apache2/sites-available/default-ssl.conf.bak
Ahora, abra el archivo de host virtual de SSL para realizar ajustes:
sudo nano /etc/apache2/sites-available/default-ssl.conf
En su interior, con la mayoría de los comentarios eliminados, el archivo de host virtual debería tener un aspecto similar al siguiente por defecto:
/etc/apache2/sites-available/default-ssl.conf
<IfModule mod_ssl.c>
<VirtualHost _default_:443>
ServerAdmin webmaster@localhost
DocumentRoot /var/www/html
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
SSLEngine on
SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem
SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key
<FilesMatch "\.(cgi|shtml|phtml|php)$">
SSLOptions +StdEnvVars
</FilesMatch>
<Directory /usr/lib/cgi-bin>
SSLOptions +StdEnvVars
</Directory>
</VirtualHost>
</IfModule>
Haremos algunos ajustes menores en el archivo. Configuraremos las cosas normales que querríamos ajustar en un archivo de host virtual (dirección de correo electrónico de ServerAdmin, ServerName, etc.), y ajustaremos las directivas SSL para que apunten a nuestros archivos de certificados y claves.
Tras realizar estos cambios, su bloque de servidor debe tener un aspecto similar a este:
/etc/apache2/sites-available/default-ssl.conf
<IfModule mod_ssl.c>
<VirtualHost _default_:443>
ServerAdmin your_email@example.com
ServerName server_domain_or_IP
DocumentRoot /var/www/html
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
SSLEngine on
SSLCertificateFile /etc/ssl/certs/apache-selfsigned.crt
SSLCertificateKeyFile /etc/ssl/private/apache-selfsigned.key
<FilesMatch "\.(cgi|shtml|phtml|php)$">
SSLOptions +StdEnvVars
</FilesMatch>
<Directory /usr/lib/cgi-bin>
SSLOptions +StdEnvVars
</Directory>
</VirtualHost>
</IfModule>
Guarde y cierre el archivo cuando haya terminado.
(Recomendado) Modificar el archivo de host HTTP para el redireccionamiento a HTTPS
En su estado actual, el servidor proporcionará tanto tráfico HTTP no cifrado como tráfico HTTPS cifrado. Para una mayor seguridad, en la mayoría de los casos se recomienda redireccionar HTTP a HTTPS de forma automática. Si no desea ni necesita esta funcionalidad, puede omitir esta sección sin riesgo.
Para ajustar el archivo de host virtual no cifrado de modo que se redireccione todo el tráfico y cuente con cifrado SSL, podemos abrir el archivo /etc/apache2/sites-available/000-default.conf:
sudo nano /etc/apache2/sites-available/000-default.conf
Dentro de los bloques de configuración de VirtualHost, debemos añadir una directiva Redirect, que dirija todo el tráfico a la versión SSL del sitio:
/etc/apache2/sites-available/000-default.conf
<VirtualHost *:80>
. . .
Redirect "/" "https://your_domain_or_IP/"
. . .
</VirtualHost>
Guarde y cierre el archivo cuando haya terminado.
Paso 3: Ajustar el firewall
Si tiene habilitado el firewall ufw, como se recomienda en las guías de los requisitos previos, es posible que deba ajustar la configuración para permitir el tráfico de SSL. Afortunadamente, Apache registra algunos perfiles con ufw después de la instalación.
Podemos ver los perfiles disponibles escribiendo lo siguiente:
sudo ufw app list
Debería ver una lista como esta:
Output
Available applications:
Apache
Apache Full
Apache Secure
OpenSSH
Puede ver la configuración actual escribiendo lo siguiente:
sudo ufw status
Si antes sólo permitía tráfico HTTP regular, su resultado puede tener este aspecto:
Output
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
Apache ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
Apache (v6) ALLOW Anywhere (v6)
Para permitir adicionalmente la entrada de tráfico HTTPS, podemos permitir el perfil “Apache Full” y luego eliminar la asignación de perfil “Apache” redundante:
sudo ufw allow 'Apache Full'
sudo ufw delete allow 'Apache'
Con esto, su estado debería de tener este aspecto:
sudo ufw status
Output
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
Apache Full ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
Apache Full (v6) ALLOW Anywhere (v6)
Paso 4: Habilitar los cambios en Apache
Ahora que realizamos los cambios y ajustamos el firewall, podemos habilitar los módulos y encabezados SSL de Apache, y también nuestro host virtual listo para SSL, y reiniciar Apache.
Podemos habilitar mod_ssl, el módulo SSL de Apache y mod_headers, que necesitan algunas de las configuraciones de nuestro fragmento SSL, con el comando a2enmod:
sudo a2enmod ssl
sudo a2enmod headers
A continuación, podemos habilitar nuestro host virtual SSL con el comando a2ensite:
sudo a2ensite default-ssl
También debemos habilitar nuestro archivo ssl-params.conf, para leer los valores que configuramos:
sudo a2enconf ssl-params
En este punto, nuestro sitio y los módulos necesarios quedarán habilitados. Deberíamos comprobar que no haya errores de sintaxis en nuestros archivos. Podemos hacerlo escribiendo lo siguiente:
sudo apache2ctl configtest
Si la operación se completa de forma correcta, obtendrá un resultado similar a este:
Output
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1. Set the 'ServerName' directive globally to suppress this message
Syntax OK
La primera línea es solo un mensaje que le indica que la directiva ServerName no está configurada a nivel global. Si quiere deshacerse de ese mensaje, puede establecer ServerName en el nombre de dominio o la dirección IP de su servidor en /etc/apache2/apache2.conf. Esto es opcional, ya que el mensaje no causará problemas.
Si el resultado contiene Syntax OK, en su archivo de configuración no habrá errores de sintaxis. Podemos reiniciar Apache de forma segura para implementar nuestros cambios:
sudo systemctl restart apache2
Paso 5: Probar el cifrado
Ahora, estamos listos para probar nuestro servidor SSL.
Abra su navegador web y escriba https:// seguido del nombre de dominio o el IP de su servidor en la barra de direcciones:
https://server_domain_or_IP
Debido a que el certificado que creamos no está firmado por una de las autoridades de certificados de confianza de su navegador, es probable que vea una advertencia de aspecto intimidante como la que aparece a continuación:
Advertencia de certificado autofirmado de Apache
Esto está previsto y es normal. Sólo nos interesa el aspecto de cifrado de nuestro certificado. No nos importa la validación de terceros de la autenticidad de nuestro host. Haga clic en “ADVANCED” y luego en el enlace proporcionado para acceder a su host de cualquier manera:
Anulación autofirmada de Apache
Debería acceder a su sitio. Si observa la barra de direcciones del navegador, verá un candado con una “x” encima. En este caso, esto solo significa que no es posible validar el certificado. Todavía se está cifrando su conexión.
Si configuró Apache para redireccionar HTTP a HTTPS, también puede comprobar si el redireccionamiento funciona de manera correcta:
http://server_domain_or_IP
Si como resultado aparece el mismo icono, significa que el redireccionamiento funcionó de manera correcta.
Paso 6: Cambiar a una redireccionamiento permanente
Si su redireccionamiento funcionó de forma correcta y está seguro que quiere permitir solo tráfico cifrado, deberá modificar el host virtual de Apache no cifrado de nuevo para que el redireccionamiento sea permanente.
Abra de nuevo el archivo de configuración de su bloque de servidor:
sudo nano /etc/apache2/sites-available/000-default.conf
Encuentre la línea de Redirect que agregamos previamente. Añada permanent a esa línea, que cambia el redireccionamiento del tipo temporal 302 al tipo permanente 301:
/etc/apache2/sites-available/000-default.conf
<VirtualHost *:80>
. . .
Redirect permanent "/" "https://your_domain_or_IP/"
. . .
</VirtualHost>
Guarde y cierre el archivo.
Revise su configuración en busca de errores de sintaxis:
sudo apache2ctl configtest
Cuando esté listo, reinicie Apache para que el redireccionamiento sea permanente:
sudo systemctl restart apache2
Conclusión
De esta manera, habrá configurado su servidor de Apache para aplicar un cifrado seguro a las conexiones de los clientes. Esto le permitirá proporcionar las solicitudes de forma segura y evitará que individuos externos lean su tráfico.

69
Linux/crons y crontab.txt Normal file
View File

@ -0,0 +1,69 @@
Utilizando crontab
Ejecutamos la edición del crontab con crontab -e, en algunas distros (como ubuntu) nos da la opcion de elegir el editor de textos que deseemos, los demás nos quedamos con vi. El archivo crontab lucirá algo asi.
# m h dom mon dow user command
donde:
- m corresponde al minuto en que se va a ejecutar el script, el valor va de 0 a 59
- h la hora exacta, se maneja el formato de 24 horas, los valores van de 0 a 23, siendo 0 las 12:00 de la medianoche.
- dom hace referencia al día del mes, por ejemplo se puede especificar 15 si se quiere ejecutar cada dia 15
- dow significa el día de la semana, puede ser numérico (0 a 7, donde 0 y 7 son domingo) o las 3 primeras letras del día en inglés: mon, tue, wed, thu, fri, sat, sun.
- user define el usuario que va a ejecutar el comando, puede ser root, u otro usuario diferente siempre y cuando tenga permisos de ejecución del script.
- command refiere al comando o a la ruta absoluta del script a ejecutar, ejemplo: /home/usuario/scripts/actualizar.sh, si acaso llama a un script este debe ser ejecutable
Para que quedara claro unos cuantos ejemplos de tareas de cron explicados:
Ejecutará el script actualizar.sh a las 10:15 a.m. todos los días
15 10 * * * usuario /home/usuario/scripts/actualizar.sh
Ejecutará el script actualizar.sh a las 10:15 p.m. todos los días
15 22 * * * usuario /home/usuario/scripts/actualizar.sh
Ejecutará una actualización todos los domingos a las 10:00 a.m
00 10 * * 0 root apt-get -y update Usuario root
Usuario root ejecutará una actualización todos los domingos (sun) a las 10:45 a.m
45 10 * * sun root apt-get -y update
El día 20 de noviembre a las 7:30 el usuario correra el script
30 7 20 11 * usuario /home/usuario/scripts/actualizar.sh
El día 11 de noviembre a las 7:30 a.m. y que sea domingo, el usuario festejará su sysadmin (o sea a mí)
30 7 11 11 sun usuario /home/usuario/scripts/pastel_con_velitas.sh
Un molesto recordatorio cada minuto de cada hora todos los días (NO recomendable).
01 * * * * usuario /home/usuario/scripts/molestorecordatorio.sh
Igual se pueden manejar rangos especiales:
A las 5:30 de la tarde todos los días de lunes a viernes.
30 17 * * 1,2,3,4,5
A las 12 del día todos los días primero, quince y 28 de cada mes (ideal para nóminas)
00 12 1,15,28 * *
Si esto resulta confuso, crontab maneja cadenas especiales para definir estos rangos.
@reboot Ejecuta una vez, al inicio
@yearly ejecuta sólo una vez al año: 0 0 1 1 *
@annually igual que @yearly
@monthly ejecuta una vez al mes, el día primero: 0 0 1 * *
@weekly Semanal el primer minuto de la primer hora de la semana. 0 0 * * 0″.
@daily diario, a las 12:00A.M. 0 0 * * *
@midnight igual que @daily
@hourly al primer minuto de cada hora: 0 * * * *
Su uso es muy sencillo.
@hourly usuario /home/usuario/scripts/molestorecordatorio.sh
@monthly usuario /home/usuario/scripts/respaldo.sh
@daily root apt-get update && apt-get -y upgrade
Por último y no menos importante: Administracion de trabajos en cron
Remplaza el existente archivo crontab con un archivo definido por el usuario
crontab archivo
Editar el archivo crontab del usuario, cada linea nueva sera una nueva tarea de crontab.
crontab -e
Lista todas las tareas de crontab del usuario
crontab -l
Borra el crontab del usuario
crontab -d
Define el directorio de crontab del usuario (este debe tener permisos de escritura y ejecucion del usuario)
crontab -c dir
Prefijo para manejar el crontab de otro usuario, ejemplos:
crontab -u usuario
$ sudo crontab -l -u root
$ sudo crontab -e usuario2
#crontab -d -u usuario
Listar usuarios con tareas cron: "ls -la /var/spool/cron"
Sacar las tareas que ejecutan los usuarios y salvarla a texto plano: "crontab -l -u usuario__que_ejecuta_tarea > usuario_tareas_cron"

55
Linux/desactivar temporalmente el historial de Bash.txt Normal file
View File

@ -0,0 +1,55 @@
unset HISTFILE
Para desactivar el historial durante la sesión actual, sólo es necesario borrando la variable de entorno HISTFILE:
unset HISTFILE
De esta forma, mientras la sesión está activa es posible acceder al historial normalmente para ver el registro de los últimos comandos ejecutados, incluyendo aquellos ejecutados en la sesión actual, pero el resultado es que éstos no serán guardados en el archivo ~/.bash_history al finalizar la sesión. Sin embargo, para otras sesiones que puedan estar conviviendo simultáneamente, el comportamiento del historial será de manera tradicional. Es decir, esta configuración sólo afecta a la sesión actual.
Los comandos que no serán guardados en disco serán todos los que se ejecuten en la sesión actual, no sólo aquellos que se ejecuten luego del comando unset HISTFILE.
Existe otra técnica que consiste en agregar la opción ignorespace o ignoreboth en la variable de entorno HISTCONTROL. Esta variable controla cómo los comandos son guardados en disco (man bash). Utilizar ignorespace o ignoreboth causa que los comandos que comienzan con uno o más espacios en blanco no sean guardados en el historial. Por defecto, en la mayoría de las distribuciones Bash utiliza la variable HISTCONTROL configurada con la opción ignoredups, la cual previene que se guarden entradas duplicadas en el historial. Si se agrega la opción ignorespace, o se cambia por ignoreboth, los comandos que comienzan con espacio no se guardan en el historial.
Veamos un ejemplo:
[emi@hal9000 ~]$ echo $HISTCONTROL
ignoredups
Actualmente la variable HISTCONTROL está configurada con la opción ignoredups. Cambio ignoredups por ignoreboth:
[emi@hal9000 ~]$ HISTCONTROL="ignoreboth"
[emi@hal9000 ~]$ echo $HISTCONTROL
ignoreboth
Ejecuto algunos comandos para que se guarden en el historial:
[emi@hal9000 ~]$ ping www.google.com > /dev/null 2>&1
^C
[emi@hal9000 ~]$ pwd
/home/emi
Tanto ping como pwd se guardan en el historial:
[emi@hal9000 ~]$ history | tail -n 4
1024 export $HISTCONTROL
1025 ping www.google.com > /dev/null 2>&1
1026 pwd
1027 history | tail -n 4
Ahora ejecuto un comando que comienza con espacio en blanco y otro que no:
[emi@hal9000 ~]$ sleep 2
[emi@hal9000 ~]$ echo hola
hola
Se observa que el comando que comienza con espacio en blanco ( sleep 2) no fue guardado en el historial:
[emi@hal9000 ~]$ history | tail -n 7
1023 echo $HISTCONTROL
1024 export $HISTCONTROL
1025 ping www.google.com > /dev/null 2>&1
1026 pwd
1027 history | tail -n 4
1028 echo hola
1029 history | tail -n 7
Cada técnica tiene sus ventajas y desventajas. La ventaja de borrar la variable HISTFILE (ejecutando unset HISTFILE), es que los comandos ejecutados permanecen en el historial durante la sesión actual, por lo cual es posible acceder a ellos a lo largo de toda la sesión para repetirlos o modificarlos. La desventaja es que al cerrar la sesión se pierden todos los comandos ejecutados durante la misma (ninguno se guarda en disco).
En cambio, la ventaja de utilizar la opción ignorespace o ignoreboth en la variable de entorno HISTCONTROL, es que sólo no se agregan al historial aquellos comandos específicos comienzan con espacio. Esta técnica permite controlar de manera más granular cuales comandos queremos guardar, y cuales no. La desventaja, es que estos comandos no se agregan al historial de ninguna forma, no se guardan en disco ni permanecen en el historial temporalmente durante la sesión actual. Por lo tanto, si el comando que no se desea guardar en el historial es un comando complejo construido con pipes, luego de ejecutarlo se perderá para siempre. Ni siquiera será posible acceder al mismo utilizando la flecha hacia arriba del teclado.
Es cuestión de utilizar la técnica que mejor se adapte a nuestras necesidades.

12
Linux/ejecutar script mysql desde cron.txt Normal file
View File

@ -0,0 +1,12 @@
crontab -e
5 10 * * * * /root/myscript.sh
myscript.sh:
mysql -uusuario -ppassword bd < myscript.sql
myscript.sql
use bd;
update tabla se campo = "constante" where id= x
chmod 755 /root/myscript.sh

23
Linux/ejecutar un script al arrancar Linux (debian).txt Normal file
View File

@ -0,0 +1,23 @@
Ejecutar un script al arrancar Linux (debian)
Normalmente Debian corre en el runlevel 2 por defecto.
Esto quiere decir, que si entras en /etc/rc2.d/ encontraras allí una lista de todos los scripts que se ejecutan al arrancar el sistema. Si nos fijamos bien todos son enlaces simbólicos a archivos que se encuentran en /etc/init.d/ que es donde están todos los daemon ,es decir, todo lo que funciona independientemente y sin emitir en la Consola un mensaje para el usuario.
De modo que para ejecutar un script o programa al arranque del sistema, primero es necesario darle características de daemon y posteriormente crees un enlace simbolico de este daemon en la carpeta /etc/rc2.d/ de la siguiente forma:
1) Darle permiso de ejecución al script, abre un Terminal y en la carpeta donde se encuentra el script digita:
$ sudo chmod +x nombredetuscript
2) Copiarlo a la carpeta /etc/init.d/
$ sudo cp nombredetuscript /etc/init.d
3) Lo hacemos daemon, es decir que se ejecute al inicio de la sesión
$ sudo update-rc.d nombredetuscript defaults
Para borrar un script haríamos:
$ sudo update-rc.d miscript.sh remove
Esto borra únicamente los enlaces simbólicos, no el script; y siempre y cuando se haya borrado el script previamente. Si se quiere borrar los enlaces aunque no se haya borrado el script, hay que utilizar la opción -f (force):
$ sudo update-rc.d -f miscript.sh remove

50
Linux/elegir version de paquete a instalar o fijar una version y que no se actualize.txt Normal file
View File

@ -0,0 +1,50 @@
ejemplo: muestra todas las versiones del paquete php y se ha de seleccionar la deseada
sudo update-alternatives --config php
# sudo update-alternatives --config php
There are 8 choices for the alternative php (providing /usr/bin/php).
Selection Path Priority Status
------------------------------------------------------------
0 /usr/bin/php8.1 81 auto mode
1 /usr/bin/php5.6 56 manual mode
2 /usr/bin/php7.0 70 manual mode
3 /usr/bin/php7.1 71 manual mode
4 /usr/bin/php7.2 72 manual mode
5 /usr/bin/php7.3 73 manual mode
6 /usr/bin/php7.4 74 manual mode
7 /usr/bin/php8.0 80 manual mode
8 /usr/bin/php8.1 81 manual mode
Fijar una version:
update-alternatives --set php /usr/bin/php8.1
A veces no aparece ahí, pero si en dpkg como es el caso de docker que se muestra:
root@localhost:~# dpkg --get-selections | grep docker
docker-ce install
docker-ce-cli install
docker-ce-rootless-extras install
docker-compose install
docker-scan-plugin install
python3-docker install
python3-dockerpty install
root@localhost:~#
root@localhost:~# echo "docker-ce hold" | dpkg --set-selections
root@localhost:~# echo "docker-ce-cli hold" | dpkg --set-selections
root@localhost:~# echo "docker-ce-rootless-extras hold" | dpkg --set-selections
root@localhost:~# echo "docker-compose hold" | dpkg --set-selections
root@localhost:~# echo "docker-scan-plugin hold" | dpkg --set-selections
root@localhost:~#
root@localhost:~# dpkg --get-selections | grep docker
docker-ce hold
docker-ce-cli hold
docker-ce-rootless-extras hold
docker-compose hold
docker-scan-plugin hold
python3-docker install
python3-dockerpty install
root@localhost:~#
Para que se vuelva a actualizar, en vez de poner hold en los echo, poner install

33
Linux/envio de mail por telnet usando bash.txt Normal file
View File

@ -0,0 +1,33 @@
EJEMPLO DE ENVIO DE MAIL DESDE BASH VIA TELNET
echo "Empezamos a enviar el mail"
(echo open 127.0.0.1 25
sleep 8
echo helo mimaquina.local
echo mail from:mimail@localhost.local
sleep 2
echo rcpt to: destino1@localhost.local
sleep 2
echo rcpt to: destino2@localhost.local
sleep 2
echo rcpt to: destino3@localhost.local
sleep 2
echo data
sleep 2
echo subject: 'ASUNTO: Prueba de envío de correo usando bash por telnet'
echo
echo Hola, aqui empieza el cuerpo del mensaje
echo
echo continuamos usando echos para completar el cuerpo con lo que queramos contar
echo Por aqui podemos seguir hasta que nos apetezca parar, justo debajo hay un ejemplo de como
echo insertar un fichero de texto en el cuerpo, para meter adjuntos utilizar los comandos telnet adecuados
echo
echo | cat /home/localuser/fichero_prueba.txt
echo
sleep 5
echo Un saludo
echo .
sleep 5
echo quit ) | telnet
echo "Finalizamos y salimos"

18
Linux/error 502 php-fpm.txt Normal file
View File

@ -0,0 +1,18 @@
archivo /etc/php/7.4/fpm/pool.d/www.conf las opciones pm.max_children
Hemos seguido las instrucciones utilizando la calculadora que aparece y hemos reconfigurado el archivo en las opciones siguientes
pm.max_children = de 5 a 111
pm.start_servers de 2 a 27
pm.min_spare_servers de 2 a 27
pm.max_spare_servers de 3 a 83
reiniciar servicios nginx y php-fpm
** Calculadora php-fpm: https://spot13.com/pmcalculator/
el valor de "Process size" sale del siguiente comando:
ps -ylC php7.3-fpm --sort:rss -u nginx

15
Linux/exportar importar paquetes linux.txt Normal file
View File

@ -0,0 +1,15 @@
Para el listar totale de paquetes instalados utilizamos el siguiente Comando:
dpkg --get-selections
Gracias a este es posible herramienta también exportar la lista de paquetes instalados:
dpkg --get-selections> mis_paquetes
Podemos luego instalarlos en otra maquina
Obtención de la lista precedente:
dpkg --set-selections <mis_paquetes
Instalación de la lista:
apt-get dselect-upgrade
El Comando dpkg -l da la lista de paquetes instalados pero con maire información. Sin embargo, no es posible utilizarlo para una lista instalar de paquetes.

17
Linux/fail2ban - ban unban.txt Normal file
View File

@ -0,0 +1,17 @@
Para saber las jaulas activas:
fail2ban-client status
Para ver todos los datos de las jaulas activas:
sudo fail2ban-client status | grep "Jail list:" | sed "s/ //g" | sudo awk '{split($2,a,",");for(i in a) system("fail2ban-client status " a[i])}' | grep "Status\|IP list"
Se utiliza el siguiente comando indicando la jaula (ejemplo postfix) y la ip a banear
sudo fail2ban-client -vvv set postfix banip 103.99.2.35
Para desbanear:
sudo fail2ban-client -vvv set postfix unbanip 103.99.2.35
Baneo con UFW:
sudo ufw insert 1 deny from x.x.x.x to any
Desbaneo con UFW:
sudo ufw delete deny from x.x.x.x to any

27
Linux/fail2ban - configuracion baneos incrementales.txt Normal file
View File

@ -0,0 +1,27 @@
El siguiente bloque hay que ponerlo en general, aunque se podría poner personalizado para cada jaula.
#
# CONFIGURACION BANEO INCREMENTAL
#
#bantime.increment permite usar la base de datos para buscar IP previamente prohibidas para aumentar un tiempo de prohibición predeterminado utilizando una fórmula especial, que por defecto es banTime 1, 2, 4, 8, 16, 32 ...
bantime.increment = true
#bantime.rndtime es el número máximo de tiempo utilizado para mezclar con el tiempo aleatorio para evitar que las botnets "inteligentes" calculen el tiempo exacto después del cual una IP puede ser desbloqueada nuevamente.
bantime.rndtime = 30m
#bantime.maxtime es el número máximo que el tiempo de prohibición puede alcanzar (no crece más)
bantime.maxtime = 7d
#bantime.factor es un coeficiente para la fórmula para calcular el crecimiento exponencial o multiplicador común. El valor predeterminado es 1 y con él el tiempo de prohibición crece en 1, 2, 4, 8, 16 ...
bantime.factor = 1
#banTime.formula utilizada por defecto para calcular el siguiente valor de Ban Time. El mismo aumento de tiempo de prohibición será alcanzado por los multiplicadores 1, 2, 4, 8, 16, 32 ...
bantime.formula = ban.Time * (1<<(ban.Count if ban.Count<20 else 20)) * banFactor
#overalljails es para sobreeescribir cualquier configuración específica por eso está comentado
#bantime.overalljails = true
Comandos de comprobación:
systemctl restart fail2ban
systemctl staus fail2ban
fail2ban-client status
sudo grep -e Ban -e Unban -e incr /var/log/fail2ban.log | grep 'IP'

9
Linux/find - busquedas de fichero y borrado condicional.txt Normal file
View File

@ -0,0 +1,9 @@
sacar espacio ocupado y ordenar:
du -ch /storage/log/ | grep M | sort -n -r | head -n 30
ver ocupacion total de logs de mas de 90 dias en megas:
find /storage/log/vmware/vmware-sps/ -type f -mtime +90 -printf "%s\n" | awk '{sum+=$1} END{print ((sum+0)/1024)/1024}'
borrar ficheros de mas de 90 dias:
find /storage/log/vmware/vmware-sps/ -type f -mtime +90 -delete

216
Linux/generar un certificado SSL-TLS gratis con certbot.txt Normal file
View File

@ -0,0 +1,216 @@
Cómo generar un certificado SSL/TLS gratis con certbot
Certbot es un cliente ACME automático y fácil de utilizar, que obtiene certificados SSL/TLS gratis para tu sitio Web, provistos por Let's Encrypt. Certbot fue desarrollado por la EFF (Electronic Frontier Foundation) como "cliente oficial" de la autoridad certificante de Let's Encrypt, pero también funciona con cualquier CA que soporte el protocolo ACME (Automated Certificate Management Environment).
Certbot (anteriormente el cliente Let's Encrypt letsencrypt-auto) es el cliente recomendado por Let's Encrypt para emitir sus certificados, y opcionalmente auto-configurar HTTPS en tu servidor Web.
Este artículo explica cómo emitir un certificado SSL/TLS gratuito de Let's Encrypt utilizando el cliente certbot utilizando el plugin webroot en Debian 7 (wheezy).
Certbot soporta un número de diferentes plugins que pueden ser utilizados para obtener y/o instalar certificados. Para aquellos usuarios poco experimentados, certbot tiene la capacidad de auto-configurar a la mayoría de los servidores HTTP, a fin de instalar el certificado generado y poner en funcionamiento HTTPS. Sin embargo, si se utiliza una configuración de HTTP/HTTPS personalizada y se cuenta con acceso a la configuración del servidor Web, resultará conveniente realizar la autenticación del dominio (ACME challenge) utilizando el servidor Web actual. Esto tiene la ventaja de no tener que detener el servicio Web durante la generación del certificado.
El modo automático levanta un servidor Web temporal para llevar a cabo la autenticación sin necesidad de intervención del usuario. Pero para ello es necesario detener el servidor corriendo en el puerto 80, lo cual implica un corte en el servicio.
El plugin webroot realiza la autenticación ACME creando un archivo temporal para cada uno de los dominios a certificar (por supuesto, todos estos dominios deben resolver al servidor donde corre certbot). Estos archivos temporales son accedidos inmediatamente por la CA, para verificar la autenticidad y autoridad de los dominios a certificar.
Este es exactamente el mismo proceso que expliqué en el artículo Cómo obtener un certificado SSL gratis de Let's Encrypt.
Antes de comenzar, configurar el servidor Web en cuestión para que el acceso a los archivos en el directorio .well-known/acme-challenge/ sea de tipo MIME "text/plain". Para el caso de servidores Nginx, configurar el directorio, dentro de la configuración del sitio, de la siguiente forma:
location '/.well-known/acme-challenge' {
default_type "text/plain";
root /var/www/linuxito.com;
}
Para el caso de Apache:
<Directory /var/www/linuxito.com/.well-known/acme-challenge>
DefaultType text/plain
</Directory>
Luego recargar la configuración (service nginx reload o service apache2/httpd reload). De esta forma no es necesario detener el servicio Web en ningún momento.
Instalación de certbot
Para los sistemas que no dispongan certbot desde paquete, la instalación es trivial. Simplemente descargar el cliente certbot-auto y otorgarle permisos de ejecución:
root@linuxito:~/scripts# wget https://dl.eff.org/certbot-auto
--2017-03-14 07:11:29-- https://dl.eff.org/certbot-auto
Resolving dl.eff.org (dl.eff.org)... 173.239.79.196
Connecting to dl.eff.org (dl.eff.org)|173.239.79.196|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 46789 (46K) [application/octet-stream]
Saving to: `certbot-auto'
100%[==============================================================================>] 46,789 --.-K/s in 0.06s
2017-03-14 07:11:30 (740 KB/s) - `certbot-auto' saved [46789/46789]
root@linuxito:~/scripts# chmod a+x certbot-auto
Generación de un certificado SSL/TLS utilizando el plugin webroot
La creación del certificado es extremadamente simple, porque el cliente se encarga de crear los archivos con el contenido correcto (antes tenía que realizarlo uno manualmente). Sólo basta con ejecutar:
./certbot-auto certonly
Por ejemplo, generar un certificado TLS para los dominios "linuxito.com" y "www.linuxito.com":
root@linuxito:~/scripts# ./certbot-auto certonly
Saving debug log to /var/log/letsencrypt/letsencrypt.log
En el primer paso, seleccionar "webroot":
How would you like to authenticate with the ACME CA?
-------------------------------------------------------------------------------
1: Place files in webroot directory (webroot)
2: Spin up a temporary webserver (standalone)
-------------------------------------------------------------------------------
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 1
Luego, especificar una dirección de correo electrónica válida:
Enter email address (used for urgent renewal and security notices) (Enter 'c' to
cancel):***@***.org
Esta dirección será utilizada para notificar al antes de que expire el certificado generado y así poder renovarlo. Recordar que los certificados emitidos por Let's Encrypt tienen una validez de 3 meses.
A continuación, aceptar los términos del servicio:
-------------------------------------------------------------------------------
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.1.1-August-1-2016.pdf. You must agree
in order to register with the ACME server at
https://acme-v01.api.letsencrypt.org/directory
-------------------------------------------------------------------------------
(A)gree/(C)ancel: A
Si se desea, es posible recibir por correo las novedades de la EFF:
-------------------------------------------------------------------------------
Would you be willing to share your email address with the Electronic Frontier
Foundation, a founding partner of the Let's Encrypt project and the non-profit
organization that develops Certbot? We'd like to send you email about EFF and
our work to encrypt the web, protect its users and defend digital rights.
-------------------------------------------------------------------------------
(Y)es/(N)o: N
Luego viene la parte importante, indicar claramente los dominios para los cuales el certificado será válido:
Please enter in your domain name(s) (comma and/or space separated) (Enter 'c'
to cancel):linuxito.com www.linuxito.com
Obtaining a new certificate
Performing the following challenges:
http-01 challenge for linuxito.com
http-01 challenge for www.linuxito.com
Es posible separar los dominios con coma o espacio en blanco.
Siguiente, especificar la raíz del sitio web ("webroot") relacionado a los dominios a certificar. La primera vez es necesario agregar un webroot:
Select the webroot for linuxito.com:
-------------------------------------------------------------------------------
1: Enter a new webroot
-------------------------------------------------------------------------------
Press 1 [enter] to confirm the selection (press 'c' to cancel): 1
Input the webroot for linuxito.com: (Enter 'c' to cancel):/var/www/linuxito.com
En este caso, la raíz del sitio Web es /var/www/linuxito.com. Una vez agregada, seleccionarla:
Select the webroot for www.linuxito.com:
-------------------------------------------------------------------------------
1: Enter a new webroot
2: /var/www/linuxito.com
-------------------------------------------------------------------------------
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2
Finalmente, se genera el nuevo certificado:
Waiting for verification...
Cleaning up challenges
Unable to clean up challenge directory /var/www/linuxito.com/.well-known/acme-challenge
Generating key (2048 bits): /etc/letsencrypt/keys/0000_key-certbot.pem
Creating CSR: /etc/letsencrypt/csr/0000_csr-certbot.pem
IMPORTANT NOTES:
- Congratulations! Your certificate and chain have been saved at
/etc/letsencrypt/live/linuxito.com/fullchain.pem. Your cert will
expire on 2017-06-12. To obtain a new or tweaked version of this
certificate in the future, simply run certbot-auto again. To
non-interactively renew *all* of your certificates, run
"certbot-auto renew"
- Your account credentials have been saved in your Certbot
configuration directory at /etc/letsencrypt. You should make a
secure backup of this folder now. This configuration directory will
also contain certificates and private keys obtained by Certbot so
making regular backups of this folder is ideal.
- If you like Certbot, please consider supporting our work by:
Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate
Donating to EFF: https://eff.org/donate-le
El certificado (cert.pem) y su clave privada (privkey.pem) quedan almacenados en el directorio /etc/letsencrypt/live/linuxito.com/:
root@linuxito:~/scripts# ll /etc/letsencrypt/live/linuxito.com/
total 4
-rw-r--r-- 1 root root 543 Mar 14 07:16 README
lrwxrwxrwx 1 root root 36 Mar 14 07:16 cert.pem -> ../../archive/linuxito.com/cert1.pem
lrwxrwxrwx 1 root root 37 Mar 14 07:16 chain.pem -> ../../archive/linuxito.com/chain1.pem
lrwxrwxrwx 1 root root 41 Mar 14 07:16 fullchain.pem -> ../../archive/linuxito.com/fullchain1.pem
lrwxrwxrwx 1 root root 39 Mar 14 07:16 privkey.pem -> ../../archive/linuxito.com/privkey1.pem
Sólo resta configurar HTTPS en Nginx o Apache, según corresponda. Recuerden que, para asegurarse que el sitio sea confiable en todos los navegadores, es necesario utilizar la cadena completa (fullchain.pem) en lugar de sólo el certificado (cert.pem), junto con la clave privada del certificado (privkey.pem).
Renovar automáticamente todos los cetificados
Certbot tiene la opción de renovar automáticamente (y de forma desatendida) todos los certificados emitidos según la configuración utilizada previamente. Para ello, simplemente se debe ejecutar ./certbot-auto renew.
Es posible hacer una corrida a modo de prueba utilizando la opción --dry-run:
root@linuxito:~/scripts# ./certbot-auto renew --dry-run
Saving debug log to /var/log/letsencrypt/letsencrypt.log
-------------------------------------------------------------------------------
Processing /etc/letsencrypt/renewal/linuxito.com.conf
-------------------------------------------------------------------------------
Cert not due for renewal, but simulating renewal for dry run
Renewing an existing certificate
Performing the following challenges:
http-01 challenge for linuxito.com
http-01 challenge for www.linuxito.com
Waiting for verification...
Cleaning up challenges
Unable to clean up challenge directory /var/www/linuxito.com/.well-known/acme-challenge
Generating key (2048 bits): /etc/letsencrypt/keys/0001_key-certbot.pem
Creating CSR: /etc/letsencrypt/csr/0001_csr-certbot.pem
-------------------------------------------------------------------------------
new certificate deployed without reload, fullchain is
/etc/letsencrypt/live/linuxito.com/fullchain.pem
-------------------------------------------------------------------------------
** DRY RUN: simulating 'certbot renew' close to cert expiry
** (The test certificates below have not been saved.)
Congratulations, all renewals succeeded. The following certs have been renewed:
/etc/letsencrypt/live/linuxito.com/fullchain.pem (success)
** DRY RUN: simulating 'certbot renew' close to cert expiry
** (The test certificates above have not been saved.)
IMPORTANT NOTES:
- Your account credentials have been saved in your Certbot
configuration directory at /etc/letsencrypt. You should make a
secure backup of this folder now. This configuration directory will
also contain certificates and private keys obtained by Certbot so
making regular backups of this folder is ideal.
Si funciona correctamente, es posible definir un cronjob que corra de forma periódica y se encargue de las renovaciones:
./path/to/certbot-auto renew --quiet --no-self-upgrade
Esto no requiere reiniciar o recargar la configuración de los servidores Web que utilizan los certificados, pues los archivos dentro de /etc/letsencrypt/live/linuxito.com/ son enlaces simbólicos a los certificados y claves.
Let's Encrypt recomienda correr esta tarea dos veces al día (eligiendo un minuto aleatorio, para aliviar la carga en sus servidores). Tal vez parezca exagerado (siendo que los certificados son válidos por tres meses) pero evitará interrupciones en el servicio en caso de que Let's Encrypt revoque certificados por alguna razón (brecha de seguridad, cambio en algoritmos de hashing, etc.) Tener en cuenta que este trabajo no realiza ninguna tarea si los certificados no están por expirar o revocados.

226
Linux/grep ejemplos.txt Normal file
View File

@ -0,0 +1,226 @@
Sintaxis del comando grep
El comando grep espera un patrón y argumentos opcionales junto con una lista de archivos si se usa sin tubería.
$ grep [options] pattern [files]
Un ejemplo sencillo es:
$ grep my file.txt
my_file
$
---BUSCAR LO QUE EMPIECE POR '^\'
Con la expresión '^\[privi' busca todo lo que empieza por privi:
grep '^\[privi' .ansible.cfg
---Searching Multiple Files
grep le permite buscar el patrón dado no solo en uno sino en varios archivos. A continuación, le mostramos cómo puede buscar un patrón en varios archivos utilizando * comodín.
$ sudo grep -i [pattern] [files]
Salida:
$ sudo grep err /var/log/messages*
/var/log/messages:Dec 28 10:36:52 centos7vm kernel: ACPI: Using IOAPIC for interrupt routing
/var/log/messages:Dec 28 10:36:52 centos7vm kernel: ACPI: PCI Interrupt Link [LNKA] (IRQs 5 9 10 *11)
/var/log/messages:Dec 28 10:36:52 centos7vm kernel: ACPI: PCI Interrupt Link [LNKB] (IRQs 5 9 *10 11)
/var/log/messages:Dec 28 10:36:52 centos7vm kernel: ACPI: PCI Interrupt Link [LNKC] (IRQs 5 *9 10 11)
/var/log/messages:Dec 28 10:36:52 centos7vm kernel: ACPI: PCI Interrupt Link [LNKD] (IRQs 5 9 10 *11)
/var/log/messages-20201225:Dec 23 23:01:00 centos7vm kernel: ACPI: Using IOAPIC for interrupt routing
/var/log/messages-20201225:Dec 23 23:01:00 centos7vm kernel: ACPI: PCI Interrupt Link [LNKA] (IRQs 5 9 10 *11)
/var/log/messages-20201225:Dec 23 23:01:00 centos7vm kernel: ACPI: PCI Interrupt Link [LNKB] (IRQs 5 9 *10 11)
/var/log/messages-20201225:Dec 23 23:01:00 centos7vm kernel: ACPI: PCI Interrupt Link [LNKC] (IRQs 5 *9 10 11)
/var/log/messages-20201225:Dec 23 23:01:00 centos7vm kernel: ACPI: PCI Interrupt Link [LNKD] (IRQs 5 9 10 *11)
/var/log/messages-20201225:Dec 23 23:01:00 centos7vm kernel: BERT: Boot Error Record Table support is disabled. Enable it by using bert_enable as kernel parameter.
/var/log/messages-20201227:Dec 27 19:11:18 centos7vm kernel: ACPI: PCI Interrupt Link [LNKA] (IRQs 5 9 10 *11)
/var/log/messages-20201227:Dec 27 19:11:18 centos7vm kernel: ACPI: PCI Interrupt Link [LNKB] (IRQs 5 9 *10 11)
/var/log/messages-20201227:Dec 27 19:11:18 centos7vm kernel: ACPI: PCI Interrupt Link [LNKC] (IRQs 5 *9 10 11)
/var/log/messages-20201227:Dec 27 19:11:18 centos7vm kernel: ACPI: PCI Interrupt Link [LNKD] (IRQs 5 9 10 *11)
/var/log/messages-20201227:Dec 27 19:11:18 centos7vm kernel: BERT: Boot Error Record Table support is disabled. Enable it by using bert_enable as kernel parameter.
/var/log/messages-20201227:Dec 27 19:11:21 centos7vm kernel: [drm:vmw_host_log [vmwgfx]] *ERROR* Failed to send host log message.
/var/log/messages-20201227:Dec 27 19:11:21 centos7vm kernel: [drm:vmw_host_log [vmwgfx]] *ERROR* Failed to send host log message.
$
Puede observar en la salida anterior que el nombre del archivo se imprime primero antes de imprimir la línea correspondiente para indicar dónde grep encontró el patrón dado.
---Case Insensitive Search
grep ofrece buscar un patrón sin mirar el caso del patrón. Usar -i bandera para decirle a grep que ignore las mayúsculas y minúsculas.
$ grep -i [pattern] [file]
Salida:
$ grep -i it text_file.txt
This is a sample text file. It contains
functionality. You can always use grep with any
kind of data but it works best with text data.
It supports numbers like 1, 2, 3 etc. as well as
This is a sample text file. It's repeated two times.
$
---Whole Word Search
No siempre queremos una coincidencia parcial, sino que esperamos que grep coincida solo con una palabra completa. Puedes hacer eso con -w bandera.
$ grep -w [pattern] [file]
Salida:
$ grep -w is text_file.txt
This is a sample text file. It contains
This is a sample text file. It's repeated two times.
$
---Check Match Count
A veces, en lugar de la línea coincidente real, solo necesitamos el recuento de coincidencias exitosas que hizo grep. Podemos obtener este recuento usando -c .
$ grep -c [pattern] [file]
Salida:
$ grep -c is text_file.txt
2
$
---Search Sub-directories
A menudo es necesario buscar archivos no solo en el directorio de trabajo actual, sino también en subdirectorios. grep te permite hacer eso fácilmente con -r bandera.
$ grep -r [pattern] *
Salida:
$ grep -r Hello *
dir1/file1.txt:Hello One
dir1/file2.txt:Hello Two
dir1/file3.txt:Hello Three
$
Como puede observar, grep recorre cada subdirectorio dentro de un directorio actual y enumera los archivos y líneas donde se encuentra una coincidencia.
---Inverse Search
Si desea encontrar algo que no coincida con un patrón dado, grep permite hacerlo con -v bandera.
$ grep -v [pattern] [file]
Salida:
$ grep This text_file.txt
This is a sample text file. It contains
This is a sample text file. It's repeated two times.
$ grep -v This text_file.txt
several lines to be used as part of testing grep
functionality. You can always use grep with any
kind of data but it works best with text data.
It supports numbers like 1, 2, 3 etc. as well as
alphabets and special characters like - + * # etc.
$
Puede comparar la salida de grep comando en el mismo patrón y archivo con y sin -v bandera. Con -v, se imprimen las líneas que no coincidan con el patrón.
---Print Line Numbers
grep le permite imprimir números de línea junto con líneas impresas, lo que facilita saber dónde está la línea en el archivo. Usar -n opción como se muestra para obtener números de línea en la salida.
$ grep -n [pattern] [file]
Salida:
$ grep -n This text_file.txt
1:This is a sample text file. It contains
7:This is a sample text file. It's repeated two times.
$
---Limit grep Output
Para archivos grandes, como registros, etc., la salida grep puede ser larga y es posible que solo necesite un número fijo de líneas en la salida en lugar de hacer coincidir todo. Nosotros podemos usar -m[num] para limitar las líneas impresas por núm. He aquí cómo usarlo:
$ grep -m[num] [pattern] [file]
Observe cómo el uso de -m flag afecta la salida de grep para el mismo conjunto de condiciones en el siguiente ejemplo:
$ grep It text_file.txt
This is a sample text file. It contains
It supports numbers like 1, 2, 3 etc. as well as
This is a sample text file. It's repeated two times.
$ grep -m2 It text_file.txt
This is a sample text file. It contains
It supports numbers like 1, 2, 3 etc. as well as
$
---Display Additional Lines
A menudo, no solo necesitamos las líneas que tienen un patrón coincidente, sino algunas líneas arriba o abajo para un mejor contexto.
Es posible imprimir una línea por encima o por debajo (o ambos) de una línea que tiene un patrón usando grep usando -A, -B or -C banderas con num valor. Aquí num indica el número de líneas adicionales que se imprimirán justo encima o debajo de la línea correspondiente. Esto es aplicable a todas las coincidencias que grep encuentra en el archivo o lista de archivos especificados.
$ grep -A[num] [pattern] [file]
# imprime la busqueda y las [num] líneas indicadas posteriores
$ grep -B[num] [pattern] [file]
# imprime la busqueda y las [num] líneas indicadas anteriores
$ grep -C[num] [pattern] [file]
# imprime la busqueda y las [num] líneas indicadas posteriores y anteriores
---List File Names
Para imprimir solo el nombre de los archivos donde se encuentra un patrón en lugar de las líneas realmente coincidentes, use -l bandera.
$ grep -l [pattern] [file]
Aquí hay un ejemplo de ejecución:
$ grep -l su *.txt
file.txt
text_file.txt
$
Print Exact Lines
---A veces necesitamos imprimir líneas que coincidan exactamente con un patrón dado, no con una parte de él. grep permite -x bandera para hacer precisamente eso.
$ grep -x [pattern] [file]
En el siguiente ejemplo, file.txt contiene una línea con una sola palabra "support" y, como tal, grep hace coincidir con -x marca sin tener en cuenta las líneas que pueden contener las palabras "apoyo" junto con otro texto.
$ grep -x support *.txt
file.txt:support
$
---Match Starting String
Usando expresiones regulares, podemos encontrar una cadena al comienzo de una línea. He aquí cómo hacerlo.
$ grep [options] "^[string]" [file]
Ejemplo:
$ grep It text_file.txt
This is a sample text file. It contains
It supports numbers like 1, 2, 3 etc. as well as
This is a sample text file. It's repeated two times.
$ grep ^It text_file.txt
It supports numbers like 1, 2, 3 etc. as well as
$
Observe cómo usar ^ carácter cambia la salida. ^ indica el inicio de la cadena y grep coinciden ^It como cualquier línea que comience con la palabra It. Incluir entre comillas puede ayudar cuando el patrón contiene espacios, etc.
---Match Ending String
Otra expresión regular útil común es hacer coincidir el final del patrón de línea.
$ grep [options] "[string]$" [file]
Ejemplo:
$ grep "\." text_file.txt
This is a sample text file. It contains
functionality. You can always use grep with any
kind of data but it works best with text data.
It supports numbers like 1, 2, 3 etc. as well as
alphabets and special characters like - + * # etc.
This is a sample text file. It's repeated two times.
$ grep "\.$" text_file.txt
kind of data but it works best with text data.
alphabets and special characters like - + * # etc.
This is a sample text file. It's repeated two times.
$
Intentamos igualar un . carácter al final de la línea. Dado que el punto (.) Es un carácter de significado especial, debemos escapar de él con \ personaje. Una vez más, observe cómo varía la salida cuando simplemente hacemos . personaje y cuando usamos $ para instruir a grep para que coincida solo con las líneas que terminan con . (no los que pueden contenerlo en algún lugar intermedio).
---Use Pattern File
Puede haber situaciones en las que tenga una lista compleja de patrones que utilice con frecuencia. En lugar de escribirlo todo el tiempo, puede especificar una lista de patrones en un archivo y usar con -f bandera. El archivo debe contener un patrón por línea.
$ grep -f [pattern_file] [file_to_match]
En nuestro ejemplo, hemos creado nombres de archivos de patrones pattern.txt con los siguientes contenidos:
$ cat pattern.txt
This
It
$
Para usarlo, usa -f bandera.
$ grep -f pattern.txt text_file.txt
This is a sample text file. It contains
It supports numbers like 1, 2, 3 etc. as well as
This is a sample text file. It's repeated two times.
$
---Specify Multiple Patterns
grep permite especificar múltiples patrones usando -e bandera.
$ grep -e [pattern1] -e [pattern2] -e [pattern3]...[file]
Ejemplo:
$ grep -e is -e It -e to text_file.txt
This is a sample text file. It contains
several lines to be used as part of testing grep
It supports numbers like 1, 2, 3 etc. as well as
This is a sample text file. It's repeated two times.
$
Specify Extended RegEx
grep también admite expresiones regulares extendidas o ERE usando -E bandera. Esto es similar a egrep comando en Linux.
El uso de ERE tiene una ventaja cuando desea tratar a los metacaracteres como están y no desea sustituirlos por cadenas como grep. Esto le brinda más flexibilidad en términos de escapar de ellos, como debemos hacer en el caso de grep. Dicho esto, usando -E con grep es equivalente a egrep mando.
$ grep -E '[Extended RegEx]' [file]
Aquí hay un uso de ERE en el que queremos imprimir líneas que no están comentadas o en blanco. Esto es especialmente útil para encontrar algo en archivos de configuración grandes. He usado adicionalmente -v bandera para NO imprimir líneas que coincidan con el patrón '^(#|$)'.
$ sudo grep -vE '^(#|$)' /etc/ssh/sshd_config
HostKey /etc/ssh/ssh_host_rsa_key
HostKey /etc/ssh/ssh_host_ecdsa_key
HostKey /etc/ssh/ssh_host_ed25519_key
SyslogFacility AUTHPRIV
AuthorizedKeysFile .ssh/authorized_keys
PasswordAuthentication yes
ChallengeResponseAuthentication no
GSSAPIAuthentication yes
GSSAPICleanupCredentials no
UsePAM yes
X11Forwarding yes
AcceptEnv LANG LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_MESSAGES
AcceptEnv LC_PAPER LC_NAME LC_ADDRESS LC_TELEPHONE LC_MEASUREMENT
AcceptEnv LC_IDENTIFICATION LC_ALL LANGUAGE
AcceptEnv XMODIFIERS
Subsystem sftp /usr/libexec/openssh/sftp-server
$

70
Linux/grep.txt Normal file
View File

@ -0,0 +1,70 @@
grep es un comando que nos servirá para encontrar texto dentro del archivo que le indiquemos. Su nombre proviene de g/re/p, un comando que sirve para algo parecido en un editor de textos de Unix/Linux. Como otros muchos comandos, grep tiene muchas opciones disponibles que añadiremos en forma de letras y cada una servirá para una tarea diferente. Al combinar estas opciones seremos capaces de realizar búsquedas complejas en uno o varios archivos. A continuación te enseñamos todo lo que necesitas saber.
Antes que nada explicaremos las opciones disponibles:
–i: no diferenciará entre mayúsculas y minúsculas.
–w: fuerza que sólo encuentre palabras concretas.
–v: selecciona las líneas que no coinciden.
–n: muestra el número de la línea con las palabras de solicitadas.
–h: elimina el prefijo del nombre del archivo Unix en la salida.
–r: busca directorios recursivamente.
–R: como -r pero sigue todos los enlaces simbólicos.
–l: muestra sólo nombres de archivos con las líneas seleccionadas.
–c: muestra sólo una cuenta por archivo de las líneas seleccionadas.
–color: muestra los patrones coincidentes en colores.
Básico:
grep Imágenes /home/pablinux/Documentos/830.desktop
Hay que tener en cuenta que en este artículo escribiremos ejemplos que hay que modificar según nuestras preferencias de búsqueda. Al decir «Archivo», «Palabra», etc, nos estaremos refiriendo al archivo con su ruta. Si yo hubiera escrito solo «grep Imágenes 830.desktop» habría recibido un mensaje diciendo que el archivo no existe. O así sería a no ser que el archivo estuviera en el directorio raíz.
Otros ejemplos serían:
grep -i imágenes /home/pablinux/Documentos/830.desktop, donde «imágenes» sería la palabra que queremos encontrar y el resto el archivo con su ruta. Este ejemplo buscaría «imágenes» en el archivo «830.desktop» sin distinguir entre mayúsculas y minúsculas.
grep -R imágenes: buscaría todas las líneas de un directorio y todos sus subdirectorios donde se encontrara la palabra «imágenes».
grep -c ejemplo prueba.txt: esto nos buscaría y mostraría el total de veces que «ejemplo» aparece en un archivo llamado «prueba.txt.
Con grep también podemos buscar archivos
Si lo que queremos es encontrar el archivo 830.desktop, escribiremos el siguiente comando:
grep 830.desktop
Esto realizará una búsqueda del archivo «830.desktop» en nuestra carpeta personal, es decir, si el archivo se encuentra en la carpeta personal de otro usuario no la encontrará. Esto es lo más normal del mundo porque un usuario no tiene permiso para acceder al contenido de otro sin su clave.
Cómo realizar búsquedas recursivas
grep también nos permite realizar búsquedas sujetas a reglas o pautas recurrentes. Por ejemplo, leer todos los archivos de cada directorio que contengan la palabra «Pablinux». Para ello escribiremos:
grep -r Pablinux /home/
O bien:
grep -R Pablinux /home/
Veremos los resultados de «Pablinux» en una linea separada precedida del nombre del archivo en el que fue encontrado. Si no queremos ver los nombres del archivo en la salida de datos usaremos la opción -h (de «hide»; esconder):
grep -h -R Pablinux /home/
Podemos unir las opciones y escribir «-hR» sin las comillas.
Cómo realizar búsquedas de palabras exactas
A veces hay archivos que contienen lo que queremos buscar algo más. Por ejemplo, esto nos puede pasar en palabras compuestas y buscando «bosques» podemos encontrar «guardabosques». Si queremos encontrar una palabra exacta usaremos la opción -w:
grep -w bosques /home/pablinux/Documentos/vacaciones.txt
El anterior comando buscaría «bosques», ignorando guardabosques, en el archivo «vacaciones.txt» en la ruta indicada. Si lo que queremos es buscar dos palabras diferentes usaremos el comando egrep:
egrep -w bosques|plantas /ruta/del/archivo
Saber cuántas veces aparece una palabra en un archivo
grep también es capaz de contar cuántas veces aparece una palabra en un archivo. Para ello usaremos la opción -c:
grep -c prueba /ruta/al/archivo
Añadiendo la opción -n lo que veremos es el número de la línea en la que aparece la palabra.
Búsquedas inversas
También podemos hacer lo contrario, es decir, buscar las líneas que no contengan una palabra. Para ello usaremos la opción -v, lo que quedaría de la siguiente manera:
grep -v la ruta/al/archivo
El comando anterior mostraría todas las lineas que no contuvieran la palabra «la». Esto puede venir bien en documentos o listas en las que una palabra se repita muchas veces y, por alguna razón, necesitemos acceder al resto de líneas.
Accediendo a la información del sistema con grep
Modelo del PC
grep no solo es capaz de buscar dentro de archivos. También es capaz de mirar información del sistema. En la captura anterior podemos ver cómo nos muestra qué modelo de PC tenemos (ya sé que no es el portátil más potente del mundo). Para ello hemos usado el comando:
cat /proc/cpuinfo | grep -i 'Model'
O bien:
grep -i 'Model' /proc/cpuinfo
Si lo que queremos es ver los nombres de las unidades del disco escribiremos:
dmesg | egrep '(s|h)d[a-z]'
Cómo listar sólo los nombres de los archivos que coinciden
Si queremos ver una lista con sólo los nombres de los archivos que coinciden con una búsqueda usaremos la opción -l como se muestra a continuación:
grep -l 'main' *.c
Y si queremos ver la palabra en colores escribiremos:
grep --color palabra /ruta/al/archivo

40
Linux/habilitar arranque servicio al inicio en linux.txt Normal file
View File

@ -0,0 +1,40 @@
MODO 1
Para activarlo poner el siguiente comando:
systemctl enable [monbre del servicio sin path]
ejemplo:
systemctl enable pandora_agent_daemon
Para desactivarlo en vez de enable poner disable
MODO 2
Se puede usar el comando chkconfig
Si se indica como argumento el nombre de algún servicio nos regresará su estatus:
#>chkconfig smb
#>smb on
Sin ningún argumento nos dará una lista con el status de todos los servicios:
#>chkconfig
#>httpd off
#>mysql on
#>smb on
Si se desea que el servidor web apache (httpd) inicie cuando se entra en el nivel 5, entonces usamos la opción --level:
#> chkconfig --level 5 httpd on
Si se desea que la base de datos MySQL no se inicie en los niveles 3 y 5, solo hasta que el administrador decida arrancarla:
#> chkconfig --level 35 mysql off
Etc.
PARA ARRANQUES MAS MANUALES
En el modo de init normal (el 3) habría que crear un enlace simbolico
bajo el directorio /etc/rc3.d/ que enlace con el servicio deseado, por ejemplo:
ln -S /etc/init.d/pandora_agent_daemon /etc/rc3.d/S10pandora_agent_daemon
quedando:
root@srv1:~# ls /etc/rc3.d/ -la
total 20
drwxr-xr-x 2 root root 4096 Nov 28 16:27 .
drwxr-xr-x 123 root root 12288 Nov 28 14:16 ..
...
lrwxrwxrwx 1 root root 30 Nov 28 16:27 S01pandora_agent_daemon -> ../init.d/pandora_agent_daemon
...
Hay que tener en cuenta que el enlace debe empezar con 'S' para start o con 'K' para kill
Mas info: https://www.linuxtotal.com.mx/index.php?cont=info_admon_003

65
Linux/habilitar diferentes php en apache (alternatives).txt Normal file
View File

@ -0,0 +1,65 @@
On your system, if you have installed multiple versions of PHP (eg PHP 8.1, 8.0, 7.4, 7.3, 7.2, 7.1 and 5.6).
PHP 7.2 is running as default PHP for Apache and CLI. For any requirement, you need to use PHP 5.6.
Then you don’t need to remove PHP 7.2. You can simply switch your PHP version to default used for Apache and command line.
We assume you have installed multiple PHP version on your Debian system. Now you need to switch the active PHP version for CLI and Apache2.
This tutorial will help you to switch between multiple PHP versions for Apache server and CLI on Debian.
We have installed PHP 8.1, PHP 7.4 and PHP 5.6 on our Debian system. You can use the same for other PHP versions by changes commands accordingly.
>>> Enable PHP 8.1 as Default Version
You need to set PHP 8.1 as your active PHP version for CLI and Apache2 both.
You can do this by disabling Apache2 modules for all other installed PHP versions and configure CLI using the update-alternatives command.
Apache:-
Run the following command to disable Apache module for other PHP versions.
sudo a2dismod php7.4 php5.6
Now, enable PHP 8.1 module in Apache server.
sudo a2enmod php8.1
sudo service apache2 restart
Command Line Interface:-
sudo update-alternatives --set php /usr/bin/php8.1
sudo update-alternatives --set phar /usr/bin/phar8.1
sudo update-alternatives --set phar.phar /usr/bin/phar.phar8.1
sudo update-alternatives --set phpize /usr/bin/phpize8.1
sudo update-alternatives --set php-config /usr/bin/php-config8.1
Note – The phpize8.1 and php-config8.1 command is available in php8.1-dev package. This is more useful for compiling PHP modules using pecl.
>>> Enable PHP 7.4 as Default Version
You need to set PHP 7.4 as your active PHP version for CLI and Apache2 both.
You can do this by disabling Apache2 modules for all other installed PHP versions and configure CLI using the update-alternatives command.
Apache:-
Run the following commands to disable Apache module for other PHP versions
sudo a2dismod php8.1 php5.6
Now, enable PHP 7.4 module in Apache server.
sudo a2enmod php7.4
sudo service apache2 restart
Command Line Interface:-
sudo update-alternatives --set php /usr/bin/php7.4
sudo update-alternatives --set phar /usr/bin/phar7.4
sudo update-alternatives --set phar.phar /usr/bin/phar.phar7.4
sudo update-alternatives --set phpize /usr/bin/phpize7.4
sudo update-alternatives --set php-config /usr/bin/php-config7.4
Note – The phpize7.4 and php-config7.4 command is available in php7.4-dev package. This is more useful for compiling PHP modules using pecl.
>>> Enable PHP 5.6 as Default Version
The developers of PHP are no longer supporting PHP 5.6. It is strongly recommended to upgrade to higher PHP version like 7.4 or 8.1. But still you can install and Use php 5.6 on your Debian system if your application required PHP 5.6. Let’s set PHP 5.6 as your default version for CLI and Apache2 both.
Apache:-
Run the following commands to disable other PHP versions like (php 8.1, php7.4 etc) for Apache and command line.
sudo a2dismod php7.4 php8.1 php8.0
Now, enable PHP 5.6 module in Apache server.
sudo a2enmod php5.6
sudo service apache2 restart
Command Line:-
sudo update-alternatives --set php /usr/bin/php5.6
sudo update-alternatives --set phar /usr/bin/phar5.6
sudo update-alternatives --set phar.phar /usr/bin/phar.phar5.6
sudo update-alternatives --set phpize /usr/bin/phpize5.6
sudo update-alternatives --set php-config /usr/bin/php-config5.6
Note – The phpize5.6 and php-config5.6 command is available in php5.6-dev package. This is more useful for compiling PHP modules using pecl.

61
Linux/hostap_linux.txt Normal file
View File

@ -0,0 +1,61 @@
PROCEDIMIENTO PARA CREAR UN HOST AP CON LINUX Y PASAR LA WIFI A LA ETHERNET
sudo apt-get install hostapd
sudo nano /etc/hostapd/hostapd.conf
interface=wlan0
driver=nl80211
ssid=my_hotspot
channel=1
hw_mode=g
auth_algs=1
wpa=3
wpa_passphrase=1234567890
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP CCMP
rsn_pairwise=CCMP
sudo apt-get install dhcp3-server
sudo nano /etc/default/isc-dhcp-server
INTERFACES=”wlan0″
sudo nano /etc/dhcp/dhcpd.conf
#option definitions common to all supported networks…
#option domain-name “example.org”;
#option domain-name-servers ns1.example.org, ns2.example.org;
#default-lease-time 600;
#max-lease-time 7200;
subnet 10.10.0.0 netmask 255.255.255.0 {
range 10.10.0.2 10.10.0.16;
option domain-name-servers 8.8.4.4, 208.67.222.222;
option routers 10.10.0.1;
}
sudo nano /etc/network/interfaces
auto lo
iface lo inet loopback
auto wlan0
iface wlan0 inet static
address 10.10.0.1
netmask 255.255.255.0
sudo nano /etc/sysctl.conf
net.ipv4.ip_forward=1
sudo nano /etc/rc.local
sudo iptables -t nat -A POSTROUTING -s 10.10.0.0/16 -o eth0 -j MASQUERADE
reboot
SI NO FUNCIONA INTRODUCIR LAS SIGUIENTES LINEAS EN CONSOLA:
sudo nmcli nm wifi off
sudo rfkill unblock wlan
sudo ifconfig wlan0 10.10.0.1/24 up
sleep 1
sudo service isc-dhcp-server restart
sudo service hostapd restart

31
Linux/instalar entorno grafico y xrdp en server y luego deshabilitarlo.txt Normal file
View File

@ -0,0 +1,31 @@
instalar un entorno gráfico
yum groupinstall "Server with GUI"
levantar entorno gráfico
systemctl start graphical.target
instalar XRDP
yum install xrdp
iniciar el servicio
systemctl start xrdp
**************************************************
deshabilitar la interface gráfica
init 3
systemctl disable graphical.target
parar el servicio XRDP instalado y deshabilitado del inicio
systemctl stop xrdp
systemctl disable xrdp
******************************************************
Si queremos volver a utilizar el entorno gráfico habría que hacer lo siguiente
init 5
systemctl start xrdp
Y después accedemos con nuestro cliente RDP de WINDOWS

50
Linux/instalar php8.2 con drivers oracle y sql server en linux.txt Normal file
View File

@ -0,0 +1,50 @@
INSTALACION PHP 8.2:
apt-get install php8.2 php8.2-dev php8.2-xml php8.2-fpm -y --allow-unauthenticated
apt-get remove --purge apache2
apt-get autoremove
update-alternatives --set php /usr/bin/php8.2
#Como se ha instalado php-fpm como si fuese para apache hay que modificar el fichero "/etc/php/8.2/fpm/pool.d" y cambiar los valores existentes con www-data por nginx:
systemctl stop php8.2-fpm
sed 's/user = www-data/user = nginx/g' -i /etc/php/8.2/fpm/pool.d/www.conf
sed 's/group = www-data/group = nginx/g' -i /etc/php/8.2/fpm/pool.d/www.conf
sed 's/listen.owner = www-data/listen.owner = nginx/g' -i /etc/php/8.2/fpm/pool.d/www.conf
sed 's/listen.group = www-data/listen.group = nginx/g' -i /etc/php/8.2/fpm/pool.d/www.conf
systemctl start php8.2-fpm
#buscar en los conf.d de nginx las entradas fastcgi_pass y cambiar la versión a la 8.2 (fastcgi_pass unix:/run/php/php8.2-fpm.sock;)
systemctl restart nginx.service
INSTALACION DRIVERS SQL SERVER:
pecl config-set php_ini /etc/php/8.2/fpm/php.ini
pecl install sqlsrv
pecl install pdo_sqlsrv
printf "; priority=20\nextension=sqlsrv.so\n" > /etc/php/8.2/mods-available/sqlsrv.ini
printf "; priority=30\nextension=pdo_sqlsrv.so\n" > /etc/php/8.2/mods-available/pdo_sqlsrv.ini
phpenmod -v 8.2 sqlsrv pdo_sqlsrv
systemctl restart php8.2-fpm
TEST: php -i | grep -i sqlsrv
INSTALACION OCI8:
(si no esta instalado el cliente oracle, instalar el oracle-instantclient)
#nos aseguramos que en /etc/environment estén definidas las vbles de Oracle:
LD_LIBRARY_PATH="/usr/local/lib/oracle/19.14/client64/lib"
ORACLE_BASE="/usr/local/lib/oracle/19.14/client64/lib"
TNS_ADMIN="/usr/local/lib/oracle/19.14/client64/lib"
ORACLE_HOME="/usr/local/lib/oracle/19.14/client64/lib"
source /etc/environment
pecl install oci8 #cuando pregunte sdk y oracle poner: instantclient,/usr/local/lib/oracle/19.14/client64/lib
SI CON EL pecl FALLA SE PUEDE INSTALAR MANUALMENTE:
wget https://pecl.php.net/get/oci8-3.2.1.tgz
tar -zxvf oci8-3.2.1.tgz
cd oci8-3.2.1
phpize
./configure -with-oci8=shared,instantclient,/usr/local/lib/oracle/19.14/client64/lib
make install
printf "extension=oci8.so\n" > /etc/php/8.2/mods-available/oci8.ini
phpenmod -v 8.2 oci8
systemctl restart php8.2-fpm
TEST: php -i | grep -i oracle
PARA VER LA CONFIGURACION DE PHP COMPLETA:
php -r "phpinfo();" > phpinfo.txt
less phpinfo.txt

59
Linux/instalar servidor NTP en Ubuntu.txt Normal file
View File

@ -0,0 +1,59 @@
La subred NTP esta basada en una jerarquía de niveles, donde a cada nivel se le asigna un número denominado estrato de la siguiente forma:
Los servidores Stratum 1 (primarios) del nivel más bajo se sincronizan directamente con los servicios de hora nacional a través de un módem por satélite, radio o teléfono.
Los servidores Stratum 2 (secundarios) se sincronizan con los servidores Stratum 1 y así sucesivamente, de modo que los clientes NTP y los servidores con un número relativamente pequeño de clientes no se sincronizan con los servidores primarios públicos.
Para comprender como funciona NTP y por qué es la mejor solución para disponer de un sistema sincronizado, debemos saber que los clientes y servidores NTP se sincronizan con la escala de tiempo de la Hora Universal Coordinada (UTC), la cual es usada por los laboratorios nacionales y es difundida por radio, satélite y demás medios disponibles. Ésta es una escala de tiempo global independiente de la posición geográfica en la cual nos encontremos actualmente y no tiene restricciones para corregir la zona horaria local o el horario de verano pero el propio sistema operativo puede ejecutar estos cambios.
El protocolo usado por NTP es resistente a paquetes perdidos, repetidos o falsificados con lo cual se garantiza que la hora definida es la correcta y real; ya que la versión 4 de NTP admite alrededor de cuatro docenas de relojes de referencia a través de módem por satélite, radio y teléfono incluyendo dispositivos de audio para señales de instrumentación.
Todos los controladores de reloj de referencia requieren que el reloj de referencia solo use la hora universal coordinada (UTC) y el kernel del sistema operativo realiza los ajustes de zona horaria.
1. Cómo instalar y configurar el servidor NTP en Ubuntu 18.04 Linux
-Paso 1
Por defecto, el paquete NTP se encuentra disponible en el repositorio predeterminado de Ubuntu 18.04 LTS, de modo que para instalarlo debemos ejecutar el siguiente comando:
sudo apt install ntp -y
-Paso 2
Una vez instalado, será necesario configurar NTP para sincronizar la hora desde el servidor público NTP, para ello debemos editar el archivo ntp.conf de la siguiente forma:
sudo nano /etc/ntp.conf
-Paso 3
Será necesario reemplazar las siguientes líneas:
pool 0.ubuntu.pool.ntp.org iburst
pool 1.ubuntu.pool.ntp.org iburst
pool 2.ubuntu.pool.ntp.org iburst
pool 3.ubuntu.pool.ntp.org iburst
Estas deben ser reemplazadas por la ubicación geográfica actual, el listado completo se encuentra disponible en el siguiente enlace:
http://support.ntp.org/bin/view/Servers/NTPPoolServers
Debemos tomar el hostname en base a la zona deseada y establecerlo en el archivo que hemos abierto en Linux.
-Paso 4
Ahora vamos a reiniciar el servicio NTP y aplicar los cambios ejecutando la siguiente línea:
sudo systemctl restart ntp
Procedemos a comprobar el estado de NTP ejecutando lo siguiente:
sudo systemctl status ntp
2. Cómo instalar y configurar el cliente NTP en Ubuntu 18.04 Linux
El siguiente paso es instalar y configurar el cliente NTP con el fin de sincronizar el tiempo con el servidor NTP, pero antes debe ser necesario configurar el archivo /etc/hosts para que el servidor NTP se puede resolver a través del nombre de host.
-Paso 1
Accedemos a este archivo usando algún editor:
sudo nano /etc/hosts
Allí añadiremos la siguiente sintaxis en base a la dirección IP del servidor:
192.168.***.*** ntp-server-host
-Paso 2
Ahora vamos a instalar NTP y ntpdate con los siguientes comandos:
sudo apt install ntpdate ntp -y
-Paso 3
De forma manual comprobaremos la sincronización con el servidor NTP ejecutando lo siguiente:
sudo ntpdate ntp-server-host
-Paso 4
A continuación, vamos a deshabilitar el servicio timesyncd predeterminado del sistema Ubuntu con el siguiente comando:
sudo timedatectl set-ntp off
Ahora, vamos a editar el archivo /etc/ntp.conf y configurar alli el propio servidor NTP que hemos configurado como servidor NTP preferido para la sincronización horaria, para ello ejecutamos lo siguiente:
sudo nano /etc/ntp.conf
Alli agregamos, en este caso, la siguiente línea al final:
server ntp-server-host prefer iburst
-Paso 5
Procedemos a reiniciar el servicio para aplicar los cambios ejecutando:
sudo systemctl restart ntp
Por último, vamos a hacer uso del comando ntpq con el fin de enumerar la cola de sincronización de tiempo NTP en nuestro servidor Ubuntu 18:
ntpq -p
Alli veremos la ubicación que hemos definido para el servidor NTP.
Así, tendremos la certeza de que la sincronización de la hora de nuestro servidor es correcta y así garantizamos que todos los servicios estarán en orden.

451
Linux/install Broadcom Wifi on Linux (Trisquel).txt Normal file
View File

@ -0,0 +1,451 @@
Broadcom Linux hybrid wireless driver
Release Version: 6.30.223.141
Release Date: Wed 31 Jul 2013 11:47:12 PM PDT
DISCLAIMER
----------
This is an Official Release of Broadcom's hybrid Linux driver for use with
Broadcom based hardware.
WHERE TO GET THE RELEASE
------------------------
For General Web releases: http://www.broadcom.com/support/802.11/linux_sta.php
IMPORTANT NOTE AND DISCUSSION OF HYBRID DRIVER
----------------------------------------------
There are separate tarballs for 32 bit and 64 bit x86 CPU architectures.
Make sure you use the appropriate tarball for your machine.
Other than 32 vs 64 bit, the hybrid binary is agnostic to the specific
versions (3.5.X) and distributions (Fedora, Ubuntu, SuSE, etc). It performs
all interactions with the OS through OS specific files (wl_linux.c, wl_iw.c,
osl_linux.c) that are shipped in source form. You compile this source on
your system and link with a precompiled binary file (wlc_hybrid.o_shipped)
which contains the rest of the driver.
PRECOMPILED DRIVER
-------------------
Some distros (Ubuntu and Fedora at the least) already have a version of
this driver in their repositories precompiled, tested and ready to go.
You just use the package manager to install the proper package. If
its available for your distro, this is usually an easier solution. See
the end of this document for further discussion.
ABOUT THIS RELEASE
-------------------
This is a rollup release. It includes and deprecates all previous releases
and patches. At the time of release there are no existing patches for this
release from Broadcom.
SUPPORTED DEVICES
-----------------
The cards with the following PCI Device IDs are supported with this driver.
Both Broadcom and and Dell product names are described. Cards not listed
here may also work.
BRCM PCI PCI Dell
Product Name Vendor ID Device ID Product ID
------------- ---------- --------- -----------
4311 2.4 Ghz 0x14e4 0x4311 Dell 1390
4311 Dualband 0x14e4 0x4312 Dell 1490
4311 5 Ghz 0x14e4 0x4313
4312 2.4 Ghz 0x14e4 0x4315 Dell 1395
4313 2.4 Ghz 0x14e4 0x4727 Dell 1501/1504
4321 Dualband 0x14e4 0x4328 Dell 1505
4321 Dualband 0x14e4 0x4328 Dell 1500
4321 2.4 Ghz 0x14e4 0x4329
4321 5 Ghz 0x14e4 0x432a
4322 Dualband 0x14e4 0x432b Dell 1510
4322 2.4 Ghz 0x14e4 0x432c
4322 5 Ghz 0x14e4 0x432d
43142 2.4 Ghz 0x14e4 0x4365
43224 Dualband 0x14e4 0x4353 Dell 1520
43225 2.4 Ghz 0x14e4 0x4357
43227 2.4 Ghz 0x14e4 0x4358
43228 Dualband 0x14e4 0x4359 Dell 1530/1540
4331 Dualband 0x14e4 0x4331
4360 Dualband 0x14e4 0x43a0
4352 Dualband 0x14e4 0x43a0
To find the Device ID's of Broadcom cards on your machines do:
# lspci -n | grep 14e4
NOTABLE CHANGES
---------------
Upgraded to support 3.8.x.
Added 4352 support.
Dropped WEXT support.
REQUIREMENTS
------------
Building this driver requires that your machine have the proper tools,
packages, header files and libraries to build a standard kernel module.
This usually is done by installing the kernel developer or kernel source
package and varies from distro to distro. Consult the documentation for
your specific OS.
If you cannot successfully build a module that comes with your distro's
kernel developer or kernel source package, you will not be able to build
this module either.
If you try to build this module but get an error message that looks like
this:
make: *** /lib/modules/"release"/build: No such file or directory. Stop.
Then you do not have the proper packages installed, since installing the
proper packages will create /lib/modules/"release"/build on your system.
On Fedora install 'kernel-devel' (Development Package for building kernel
modules to match the kernel) from the Package Manager (System->
Administration-> Add/Remove Software).
On Ubuntu, you will need headers and tools. Try these commands:
# apt-get install build-essential linux-headers-generic
# apt-get build-dep linux
To check to see if you have this directory do this:
# ls /lib/modules/`uname -r`/build
BUILD INSTRUCTIONS
------------------
1. Setup the directory by untarring the proper tarball:
For 32 bit: hybrid-v35-nodebug-pcoem-portsrc.tar.gz
For 64 bit: hybrid-v35_64-nodebug-pcoem-portsrc.tar.gz
Example:
# mkdir hybrid_wl
# cd hybrid_wl
# tar xzf <path>/hybrid-v35-nodebug-pcoem-portsrc.tar.gz or
<path>/hybrid-v35_64-nodebug-pcoem-portsrc.tar.gz
2. Build the driver as a Linux loadable kernel module (LKM):
# make clean (optional)
# make
When the build completes, it will produce a wl.ko file in the top level
directory.
If your driver does not build, check to make sure you have installed the
kernel package described in the requirements above.
This driver uses cfg80211 API. Code for Wext API is present and can be built
but we have dropped support for it.
As before, the Makefile will still build the matching version for your system.
# make API=CFG80211
or
# make API=WEXT (deprecated)
INSTALL INSTRUCTIONS
--------------------
Upgrading from a previous version:
---------------------------------
If you were already running a previous version of wl, you'll want to provide
a clean transition from the older driver. (The path to previous driver is
usually /lib/modules/<kernel-version>/kernel/net/wireless)
# rmmod wl
# mv <path-to-prev-driver>/wl.ko <path-to-prev-driver>/wl.ko.orig
# cp wl.ko <path-to-prev-driver>/wl.ko
# depmod
# modprobe wl
The new wl driver should now be operational and your all done.
Fresh installation:
------------------
1: Remove any other drivers for the Broadcom wireless device.
There are several other drivers (besides this one) that can drive
Broadcom 802.11 chips. These include b43, brcmsmac, bcma and ssb. They will
conflict with this driver and need to be uninstalled before this driver
can be installed. Any previous revisions of the wl driver also need to
be removed.
Note: On some systems such as Ubuntu 9.10, the ssb module may load during
boot even though it is blacklisted (see note under Common Issues on how to
resolve this. Nevertheless, ssb still must be removed
(by hand or script) before wl is loaded. The wl driver will not function
properly if ssb the module is loaded.
# lsmod | grep "brcmsmac\|b43\|ssb\|bcma\|wl"
If any of these are installed, remove them:
# rmmod b43
# rmmod brcmsmac
# rmmod ssb
# rmmod bcma
# rmmod wl
To blacklist these drivers and prevent them from loading in the future:
# echo "blacklist ssb" >> /etc/modprobe.d/blacklist.conf
# echo "blacklist bcma" >> /etc/modprobe.d/blacklist.conf
# echo "blacklist b43" >> /etc/modprobe.d/blacklist.conf
# echo "blacklist brcmsmac" >> /etc/modprobe.d/blacklist.conf
2: Insmod the driver.
Otherwise, if you have not previously installed a wl driver, you'll need
to add a security module before using the wl module. Most newer systems
use lib80211 while others use ieee80211_crypt_tkip. See which one works for
your system.
# modprobe lib80211
or
# modprobe ieee80211_crypt_tkip
If your using the cfg80211 version of the driver, then cfg80211 needs to be
loaded:
# modprobe cfg80211
Then:
# insmod wl.ko
wl.ko is now operational. It may take several seconds for the Network
Manager to notice a new network driver has been installed and show the
surrounding wireless networks.
If there was an error, see Common issues below.
Common issues:
----------------
* After the insmod you may see this message:
WARNING: modpost: missing MODULE_LICENSE()
It is expected, not harmful and can be ignored.
* If you see this message:
"insmod: error inserting 'wl.ko': -1 Unknown symbol in module"
Usually this means that one of the required modules (as mentioned above) is
not loaded. Try this:
# modprobe lib80211 or ieee80211_crypt_tkip (depending on your os)
# modprobe cfg80211
Now re-try to insmod the wl driver:
# insmod wl.ko
* If the wl driver loads but doesn't seem to do anything:
the ssb module may be the cause. Sometimes blacklisting ssb may not
be enough to prevent it from loading and it loads anyway. (This is mostly
seen on Ubuntu/Debian systems).
Check to see if ssb, bcma, wl or b43 is loaded:
# lsmod | grep "brcmsmac\|ssb\|wl\|b43\|bcma"
If any of these are installed, remove them:
# rmmod brcmsmac
# rmmod ssb
# rmmod bcma
# rmmod wl
# insmod wl
Back up the current boot ramfs and generate a new one:
# cp /boot/initrd.img-`uname -r` somewheresafe
# update-initramfs -u
# reboot
3: Setup to always load at boot time.
The procedure to make a module load at boot time varies from distro to
distro. Consult the docs for your specific distro to see how. The
following seems to work for my setup on Fedora and Ubuntu. Check your
docs to see the procedure for your distro.
Follow these steps to have the driver load as part of the boot process:
# load driver as described above
# cp wl.ko /lib/modules/`uname -r`/kernel/drivers/net/wireless
# depmod -a
# echo modeprobe wl >> /etc/rc.local (Fedora/SUSE)
Ubuntu ships a version of wl.ko, so those need to be disabled. On my
system the were several versions, so I searched and renamed the .ko's
like this:
# sh: for i in `find /lib /var -name wl\.ko`; do mv $i ${i}.orig; done
TX POWER EXPLAINED
------------------
'iwconfig eth1 txpower' & 'iwlist eth1 txpower' set and get the drivers
user-requested transmit power level. This can go up to 32 dbm and allows
the user to lower the tx power to levels below the regulatory limit.
Internally, the actual tx power is always kept within regulatory limits
no matter what the user request is set to.
WHAT'S NEW IN RELEASE 6.30.223.126
----------------------------------
+ Upgraded to Support 3.8.x
+ Added 43142 support
+ Added 4352 support
+ Dropped WEXT support
WHAT'S NEW IN RELEASE 5.100.82.116
----------------------------------
+ Support for Linux kernels > 3.0
WHAT'S NEW IN RELEASE 5.100.82.115
----------------------------------
+ Added cfg80211 API support. The choice of API is done at compile time. If
kernel version >= 2.6.32, cfg80211 is used, otherwise wireless extension
is used. (End users should notice little difference.)
+ Supports Linux kernel 2.6.38
+ Fix for problem with rebooting while wireless disabled via airline switch.
+ Fix for PR102197 STA does not connect to hidden SSID
+ Fix for PR102214: Could not get rssi (-22)" print comes in 'dmesg' output
+ Supports monitor mode
+ Supports hidden networks
+ Supports rfkill
WHAT'S NEW IN RELEASE 5.100.82.38
---------------------------------
+ Support for bcm43227 and bcm43228
+ Fix for issue where iwconfig was sometime reporting rate incorrectly
+ Supports rfkill in kernels 2.6.31 to 2.6.36
+ Supports scan complete event (SIOCGIWSCAN)
+ Adds EAGAIN (busy signal) to query of scan results
WHAT'S NEW IN RELEASE 5.100.57.15
---------------------------------
+ Following fixes (issues introduced in 5.100.57.13)
Issue #87477 - 4313: DUT is not able to associate in WPA2-PSK TKIP/AES
Issue #87533 - NetworkManager: 4313: Unable to associate to APs with WPA2-PSK
WHAT'S NEW IN RELEASE 5.100.57.13
---------------------------------
+ 4313 PHY fixes to improve throughput stability at different ranges
+ Fix for interop issues with different APs
+ Fix for hangs seen during Fn-F2 sequence
- Support for rfkill in kernels 2.6.31 to 2.6.36
WHAT'S NEW IN RELEASE 5.60.246.6
--------------------------------
+ Supports rfkill in kernels 2.6.31 to 2.6.36
+ Fix for compile error with multicast list in kernel 2.6.34
+ Fix for #76743 - Ubuntu9.04: Network manager displays n/w's with radio disabled
WHAT'S NEW IN RELEASE 5.60.246.2
--------------------------------
+ Supports up to linux kernel 2.6.36 (from 2.6.32)
+ Fix for #86668: [Canonical] Bug #611575/617369: System will hang if
you use the F2 hot key to enable/disable wireless quickly while
wireless is still in the process of re-association with AP
WHAT'S NEW IN RELEASE 5.60.48.36
--------------------------------
+ Supports up to linux kernel 2.6.32
+ Supports hidden networks
+ Supports rfkill in kernels < 2.6.31
+ Setting power level via 'iwconfig eth1 txpower X' now operational
+ Support for bcm4313
+ Additional channels in both 2.4 and 5 Ghz bands
+ Fixed issue with tkip group keys that caused this message to repeat often:
TKIP: RX tkey->key_idx=2 frame keyidx=1 priv=ffff8800cf80e840
+ Following fixes
Issue #72216 - Ubuntu 8.04: standby/resume with WPA2 and wpa_supplicant causes
a continuous assoc/disassoc loop (issue in 2.6.24 kernel)
Issue #72324 - Ubuntu 8.04: cannot ping when Linux STA is IBSS creator with WEP
Issue #76739 - Ubuntu 9.04: unable to connect to hidden network after stdby/resume
Issue #80392 - S4 resume hang with SuSE SLED 11 and 43225
Issue #80792 - LSTA is not able to associate to AP with transit
ISSUES FIXED AND WHAT'S NEW IN RECENT RELEASES
-------------------------------------------
+ Supports monitor mode
+ Supports cfg80211
+ Supports hidden networks
+ Supports rfkill
KNOWN ISSUES AND LIMITATIONS
----------------------------
#72238 - 20% lower throughput on channels 149, 153, 157, and 161
#72324 - Ubuntu 8.04: cannot ping when Linux STA is IBSS creator with WEP
enabled
#72216 - Ubuntu 8.04: standby/resume with WPA2 and wpa_supplicant causes
a continuous assoc/disassoc loop (issue with wpa_supplicant, restarting
wpa_supplicant fixes the issue)
#76739 Ubuntu9.04: unable to connect to hidden network after stdby/resume
#76793 Ubuntu9.04: STA fails to create IBSS network in 5 Ghz band
KNOWN ISSUES AND LIMITATIONS IN EXTERNAL COMPONENTS
---------------------------------------------------
wpa_supplicant 0.6.3 + nl80211 + WEP - (Note: This would only affect you if
you are using wpa_supplicant directly from the command line and specify
nl80211 interface, e.g. "wpa_supplicant -Dnl80211 -ieth1 ..". If you are using
network manager GUI to connect it should work file.)
wpa_supplicant 0.6.3 might have a bug that affect WEP connections created
through nl80211. Upgrade to wpa_supplicant to 0.7.3 would solve this problem.
Ubuntu 10.10 kernel + nl80211 + WPA/WPA2 - (Note: This would only affect you if
you are using wpa_supplicant directly from the command line and specify
nl80211 interface, e.g. "wpa_supplicant -Dnl80211 -ieth1 ..". If you are using
network manager GUI to connect it should work file.)
Some kernel versions of Ubuntu such as 2.6.35-22 (released with Ubuntu
10.10) may have problems that affect WPA/WPA2 connections created through
nl80211. Upgrade to 2.6.35-25 or later should solve this problem.
HOW TO USE MONITOR MODE
-----------------------
To enable monitor mode:
$ echo 1 > /proc/brcm_monitor0
Enabling monitor mode will create a 'prism0' network interface. Wireshark and
other netwokk tools can use this new prism0 interface.
To disable monitor mode:
$ echo 0 > /proc/brcm_monitor0
HOW TO INSTALL A PRE-COMPILED DRIVER
-----------------------------------
Some of the major linux distros already supply a version of this driver, so
you don't have to compile your own. Most of the distros keep this driver
along with other proprietary or non-GPL drivers in a separate repository.
For further information see the documentation for your specific distro.
Fedora:
------
su -c 'rpm -Uvh
http://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-stable.noarch.rpm
http://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-stable.noarch.rpm'
su -
yum update
yum install kmod-wl
Ubuntu:
------
Go to System->Administration->Hardware Drivers
Choose the Broadcom STA wireless driver
Activate
Sometimes the driver does not show up in the Hardware Drivers choices. In
this case, try reintalling the driver from the GUI or shell like this:
From the GUI:
Package Manager (System>Administration>Synaptic Package Manager). Click the
Reload button in the upper left corner of Synaptic to refresh your index then
search for and reinstall the package named bcmwl-kernel-source.
From the shell:
sudo apt-get update
sudo apt-get --reinstall install bcmwl-kernel-source
In either GUI or text case, after reinstalling, reboot your machine.
Now go back to System->Administration->Hardware Drivers
and you should see the driver enabled and working.

15
Linux/ips Virtuales en Linux.txt Normal file
View File

@ -0,0 +1,15 @@
IPs Virtuales en Linux
se consiguen usando el servido keepalived
Este servicio tiene una configuracion en etc donde se definen las ips virtuales
Se arranca con el comando
systemctl start keepalived
la forma de ver tanto las ips fisicas como las virtuales es con el siguiente comando:
ip -brief address show
MAS INFO:
https://www.redhat.com/sysadmin/keepalived-basics

362
Linux/journalctl - como usarlo para ver y manipular los registros de Systemd.txt Normal file
View File

@ -0,0 +1,362 @@
Introducción
Algunas de las ventajas más convincentes de systemd son las que se relacionan con el proceso y registro del sistema. Al usar otros sistemas, los registros suelen estar dispersos por todo el sistema, son manejados por diferentes demonios y herramientas, y puede ser bastante difícil de interpretar cuando abarcan varias aplicaciones. Systemd intenta resolver estos problemas al proporcionar una solución de administración centralizada para registrar todos los procesos del kernel y del usuario. El sistema que recopila y administra estos registros se conoce como diario.
El diario se implementa con el demonio journald, que gestiona todos los mensajes producidos por el kernel, initrd, servicios, etc. En esta guía, veremos cómo usar la utilidad journalctl, que puede usarse para acceder y manipular los datos que se encuentran dentro del diario.
Idea general
Uno de los impulsos detrás del diario systemd es centralizar la administración de los registros, independientemente de dónde se originen los mensajes. Dado que el proceso systemd gestiona gran parte del proceso de arranque y administración de servicios, tiene sentido estandarizar la forma en que se recopila y acceden a estos registros. El demonio journald recopila datos de todas las fuentes disponibles y los almacena en un formato binario para una manipulación fácil y dinámica.
Eso nos proporciona varias ventajas significativas. Al interactuar con los datos usando una sola utilidad, los administradores pueden mostrar datos de registro de forma dinámica según sus necesidades. Esto puede ser tan simple como ver los datos del arranque de hace tres arranques o combinar las entradas de registro de forma secuencial de dos servicios relacionados para depurar un problema de comunicación.
Almacenar los datos de registro en formato binario también significa que los datos pueden mostrarse en formatos de salida arbitrarios dependiendo de lo que se necesite en el momento. Por ejemplo, para la gestión de los registros diarios puede que esté acostumbrado a ver los registros en el formato estándar de syslog, pero si decide graficar las interrupciones del servicio más adelante, puede mostrar cada entrada como un objeto JSON para que sea consumible en su servicio gráfico. Dado que los datos no se escriben en el disco en texto plano, no es necesario convertirlos cuando se necesita un distinto formato bajo demanda.
El diario systemd puede usarse con una implementación de syslog existente o puede sustituir la funcionalidad syslog, según sus necesidades. Aunque el diario systemd cubrirá la mayoría de las necesidades de registro del administrador, también puede complementar los mecanismos de registro existentes. Por ejemplo, es posible que tenga un servidor syslog centralizado que utilice para compilar datos de varios servidores, pero también es posible que quiera interconectar los registros de varios servicios en un solo sistema con el diario systemd. Puede hacer ambas cosas combinando estas tecnologías.
Configurar la hora del sistema
Una de las ventajas de usar un diario binario para el registro es la posibilidad de ver los registros en hora UTC o local libremente. systemd mostrará los resultados en hora local de manera predeterminada.
Debido a esto, antes de comenzar con el diario, nos aseguraremos de que la zona horaria esté configurada correctamente. El paquete de systemd realmente viene con una herramienta llamada timedatectl que puede ayudar con esto.
Primero, consulte qué zonas horarias están disponibles con la opción list-timezones:
timedatectl list-timezones
Esto mostrará la lista de zonas horarias disponibles en su sistema. Cuando encuentre la que coincida con la ubicación de su servidor, puede configurarla usando la opción set-timezone:
sudo timedatectl set-timezone zone
Para asegurarse de que su máquina esté usando la hora correcta actual, utilice el comando timedatectl solo o con la opción status. En la pantalla, se mostrará lo mismo:
timedatectl status
Local time: Thu 2015-02-05 14:08:06 EST
Universal time: Thu 2015-02-05 19:08:06 UTC
RTC time: Thu 2015-02-05 19:08:06
Time zone: America/New_York (EST, -0500)
NTP enabled: no
NTP synchronized: no
RTC in local TZ: no
DST active: n/a
La primera línea debe mostrar la hora correcta.
Visualización básica de registros
Para ver los registros que el demonio journald ha recopila el comando journalctl.
Cuando se utilice solo, cada entrada de diario que se encuentre en el sistema se mostrará dentro de un localizador (por lo general, less) para que pueda navegar en él Las entradas más antiguas estarán arriba:
journalctl
-- Logs begin at Tue 2015-02-03 21:48:52 UTC, end at Tue 2015-02-03 22:29:38 UTC. --
Feb 03 21:48:52 localhost.localdomain systemd-journal[243]: Runtime journal is using 6.2M (max allowed 49.
Feb 03 21:48:52 localhost.localdomain systemd-journal[243]: Runtime journal is using 6.2M (max allowed 49.
Feb 03 21:48:52 localhost.localdomain systemd-journald[139]: Received SIGTERM from PID 1 (systemd).
Feb 03 21:48:52 localhost.localdomain kernel: audit: type=1404 audit(1423000132.274:2): enforcing=1 old_en
Feb 03 21:48:52 localhost.localdomain kernel: SELinux: 2048 avtab hash slots, 104131 rules.
Feb 03 21:48:52 localhost.localdomain kernel: SELinux: 2048 avtab hash slots, 104131 rules.
Feb 03 21:48:52 localhost.localdomain kernel: input: ImExPS/2 Generic Explorer Mouse as /devices/platform/
Feb 03 21:48:52 localhost.localdomain kernel: SELinux: 8 users, 102 roles, 4976 types, 294 bools, 1 sens,
Feb 03 21:48:52 localhost.localdomain kernel: SELinux: 83 classes, 104131 rules
. . .
Es probable que tenga que desplazarse por páginas y páginas de datos, que pueden ser decenas o cientos de miles de líneas si systemd ha estado en su sistema por mucho tiempo. Esto demuestra la cantidad de datos disponibles en la base de datos del diario.
El formato será familiar para aquellos que se utilizan para el registro syslog estándar. Sin embargo, esto realmente recopila datos de más fuentes de las que las implementaciones syslog tradicionales son capaces de recopilar. Incluye registros del proceso de arranque inicial, el kernel, el initrd, el error de estándar de la aplicación y la salida. Todos ellos están disponibles en el diario.
Es posible que observe que todas las marcas de tiempo que se muestran son de hora local. Esto está disponible para cada entrada de registro ahora que tenemos nuestro tiempo local correctamente configurado en el sistema. Todos los registros se muestran usando esta nueva información.
Si desea mostrar las marcas de tiempo en hora UTC, puede usar el indicador --utc:
journalctl --utc
Filtrado del diario por hora
A pesar de que tener acceso a una colección tan grande de datos es definitivamente útil, es difícil o imposible inspeccionar y procesar mentalmente tal gran cantidad de datos. Debido a esto, una de las características más importantes de journalctl son sus opciones de filtrado.
Mostrar los registros del arranque actual
La más básica de estas que puede usar diariamente, es el indicador -b. Este indicador mostrará todas las entradas del diario que se recopilaron desde el reinicio más reciente.
journalctl -b
Esto le ayudará a identificar y administrar la información que sea pertinente para su entorno actual.
En los casos en que no se usa esta función y se muestran más de un día de arranques, verá que journalctl insertó una línea parecida a la siguiente cada vez que el sistema se cae:
. . .
-- Reboot --
. . .
Lo puede usar para separar la información de manera lógica en sesiones de arranque.
Arranques anteriores
Aunque por lo general querrá mostrar la información del arranque actual, hay ocasiones en que los arranques anteriores también son útiles. El diario puede guardar la información de varios arranques anteriores, por lo que journalctl puede usarse para mostrar la información más fácilmente.
Algunas distribuciones permiten guardar la información de los arranques anteriores de manera predeterminada, mientras que otras deshabilitan esta función. Para habilitar la información de arranque persistente, puede crear el directorio para almacenar el diario escribiendo lo siguiente:
sudo mkdir -p /var/log/journal
O puede editar el archivo de configuración del diario:
sudo nano /etc/systemd/journald.conf
En la sección [Journal], establezca la opción Storage= en “persistent” (persistente) para habilitar el registro persistente:
/etc/systemd/journald.conf
. . .
[Journal]
Storage=persistent
Cuando la opción de guardar los arranques anteriores está habilitada en su servidor, journalctl proporciona algunos comandos para ayudarlo a trabajar con los arranques como unidad de división. Para ver los arranques que journald conoce, utilice la opción --list-boots con journalctl:
journalctl --list-boots
-2 caf0524a1d394ce0bdbcff75b94444fe Tue 2015-02-03 21:48:52 UTC—Tue 2015-02-03 22:17:00 UTC
-1 13883d180dc0420db0abcb5fa26d6198 Tue 2015-02-03 22:17:03 UTC—Tue 2015-02-03 22:19:08 UTC
0 bed718b17a73415fade0e4e7f4bea609 Tue 2015-02-03 22:19:12 UTC—Tue 2015-02-03 23:01:01 UTC
Esto mostrará una línea para cada arranque. La primera columna es la compensación del arranque que puede usarse para hacer referencia fácilmente al arranque con journalctl. Si necesita una referencia absoluta, el ID del arranque está en la segunda columna. Puede saber la hora a la que se refiere la sesión de arranque con las dos especificaciones de hora que aparecen al final.
Para mostrar la información de estos arranques, puede usar la información de la primera o la segunda columna.
Por ejemplo, para ver el diario del arranque anterior, utilice el puntero relativo -1 con el indicador -b:
journalctl -b -1
También puede usar el ID de arranque invocar los datos de un arranque:
journalctl -b caf0524a1d394ce0bdbcff75b94444fe
Ventanas de tiempo
Aunque ver las entradas de registro por arranque es increíblemente útil, en ocasiones es posible que quiera solicitar ventanas de tiempo que no se alinean bien con el arranque del sistema. Este puede ser el caso especialmente cuando se trata de servidores de larga duración con un tiempo de actividad significativo.
Puede filtrar por límites de tiempo arbitrarios usando las opciones --since y --until, que restringen las entradas mostradas a aquellas posteriores o anteriores al tiempo indicado, respectivamente.
Los valores de tiempo pueden venir en varios formatos. Para los valores absolutos de tiempo, debe usar el siguiente formato:
YYYY-MM-DD HH:MM:SS
Por ejemplo, podemos ver todas las entradas desde el 10 de enero de 2015 a las 5:15 p. m. escribiendo:
journalctl --since "2015-01-10 17:15:00"
Si se omiten los componentes del formato anterior, se aplicarán algunos valores predeterminados. Por ejemplo, si se omite la fecha, se asumirá la fecha actual. Si falta el componente que hace referencia a la hora, se sustituirá por “00:00:00” (medianoche). El campo de los segundos también se puede omitir para que aparezca “00” de manera predeterminada:
journalctl --since "2015-01-10" --until "2015-01-11 03:00"
El diario también comprende algunos valores relativos y los accesos directos con nombre. Por ejemplo, puede usar las palabras “yesterday”, “today”, “tomorrow”, o “now”. Puede hacer referencia a tiempos relativos anteponiendo “-” o “+” a un valor numérico o utilizando palabras como “ago” en la construcción de las instrucciones.
Para obtener los datos del día de ayer, puede escribir lo siguiente:
journalctl --since yesterday
Si recibió informes de una interrupción del servicio que comenzó a las 9:00 a.m. y continuó hasta hace una hora, puede escribir lo siguiente:
journalctl --since 09:00 --until "1 hour ago"
Como puede ver, es relativamente fácil definir ventanas de tiempo flexibles para filtrar las entradas que desea ver.
Filtrado por interés de mensaje
En la sección anterior hemos aprendido algunas formas de filtrar los datos del diario utilizando restricciones de tiempo. En esta sección, veremos cómo filtrar según el servicio o componente que le interese. El diario systemd proporciona varias formas de hacer esto.
Por unidad
Probablemente la forma más útil de filtrar es por la unidad que le interesa. Podemos usar la opción -u para filtrar de esta manera.
Por ejemplo, para ver todos los registros de una unidad de Nginx en nuestro sistema, podemos escribir lo siguiente:
journalctl -u nginx.service
Por lo general, también querrá filtrar por tiempo para mostrar las líneas que le interesa. Por ejemplo, para comprobar cómo se está ejecutando el servicio hoy, puede escribir lo siguiente:
journalctl -u nginx.service --since today
Este tipo de enfoque resulta extremadamente útil cuando se aprovecha la capacidad del diario para intercalar registros de varias unidades. Por ejemplo, si su proceso de Nginx está conectado a una unidad PHP-FPM para procesar contenido dinámico, puede combinar las entradas de ambos en orden cronológico especificando ambas unidades:
journalctl -u nginx.service -u php-fpm.service --since today
Eso puede hacer que sea mucho más fácil detectar las interacciones entre diferentes programas y sistemas de depuración en vez de procesos individuales.
Por proceso, usuario o ID de grupo
Algunos servicios generan varios procesos secundarios para realizar el trabajo. Si ha localizado el PID exacto del proceso que le interesa, también se puede hacer un filtrado basándonos en eso.
Para hacer esto, podemos filtrar especificando el campo _PID. Por ejemplo, si el PID que nos interesa es 8088, podemos escribir lo siguiente:
journalctl _PID=8088
En otras ocasiones, es posible que quiera mostrar todas las entradas registradas de un usuario o de un grupo específico. Esto puede hacerse con los filtros _UID o _GID. Por ejemplo, si su servidor web se ejecuta bajo el usuario www-data, puede encontrar el ID de usuario escribiendo lo siguiente:
id -u www-data
33
Luego, puede usar el ID que salió en la búsqueda para filtrar los resultados del diario:
journalctl _UID=33 --since today
El diario systemd tiene muchos campos que pueden usarse para filtrar. Algunos de estos son pasados desde el proceso que se está registrando y otros son aplicados por journald usando la información que recopila del sistema en el momento del registro.
El símbolo inicial de guion bajo indica que el campo _PID es de este último tipo. El diario registra e indexa automáticamente el PID del proceso que está registrando para filtrarlo después. Puede obtener información sobre todos los campos disponibles del diario escribiendo lo siguiente:
man systemd.journal-fields
En esta guía, veremos algunas de estas opciones. Por ahora, sin embargo, vamos a repasar una opción más útil que tiene que ver con el filtrado mediante estos campos. La opción -F puede usarse para mostrar todos los valores disponibles para un determinado campo del diario.
Por ejemplo, para ver qué ID de grupo tiene entradas el diario systemd, puede escribir lo siguiente:
journalctl -F _GID
32
99
102
133
81
84
100
0
124
87
Esto mostrará todos los valores que el diario almacenó para el campo del ID de grupo. Esto puede ayudarlo a crear sus filtros.
Por ruta de componente
También podemos filtrar proporcionando una ubicación de ruta.
Si la ruta conduce a un ejecutable, journalctl mostrará todas las entradas que implican el ejecutable en cuestión. Por ejemplo, para encontrar aquellas entradas que implican el ejecutable bash, puede escribir lo siguiente:
journalctl /usr/bin/bash
Por lo general, si una unidad está disponible para el ejecutable, ese método es más limpio y proporciona mejor información (entradas de procesos secundarios asociados, etc.). A veces, sin embargo, eso no es posible.
Mostrar mensajes de kernel
Los mensajes de kernel, que suelen encontrarse en el resultado de dmesg, también se pueden recuperar del diario.
Para mostrar solo estos mensajes, podemos añadir los indicadores -k o --dmesg a nuestro comando:
journalctl -k
De manera predeterminada, esto mostrará los mensajes del kernel del arranque actual. Puede especificar un arranque alternativo usando los indicadores normales de selección de arranque que se mostraron anteriormente. Por ejemplo, para obtener los mensajes de hace cinco arranques, puede escribir lo siguiente:
journalctl -k -b -5
Por prioridad
Un filtro que suele interesar a los administradores de sistemas es el de prioridad de mensaje. Aunque a menudo es útil registrar información a un nivel muy verboso, cuando realmente se asimila la información disponible, los registros de baja prioridad pueden distraer y confundir.
Puede usar journalctl para mostrar solo mensajes de una prioridad especifica o superior usando la opción -p. Esto le permite filtrar mensajes de menor prioridad.
Por ejemplo, para mostrar solo las entradas registradas en el nivel de error o superior, puede escribir lo siguiente:
journalctl -p err -b
Esto le mostrará todos los mensajes marcados como error, crítico, alerta o emergencia. El diario implementa los niveles de mensaje syslog estándar. Puede usar el nombre de prioridad o su valor numérico correspondiente. En orden de mayor a menor prioridad, estos son:
0: emergencia
1: alerta
2: crítico
3: error
4: advertencia
5: aviso
6: información
7: depuración
Los números o nombres anteriores pueden usarse indistintamente con la opción -p. Al seleccionar una prioridad, se mostrarán los mensajes marcados en el nivel especificado y aquellos que se encuentran por encima.
Modificar la pantalla del diario
Anteriormente, hemos demostrado la selección de entradas mediante el filtrado. Sin embargo, hay otras formas de modificar el resultado. Podemos ajustar la pantalla journalctl para que se adapte a varias necesidades.
Truncar o ampliar el resultado
Podemos ajustar la forma en que journalctl muestra datos indicándole que reduzca o amplíe el resultado.
Por defecto, journalctl mostrará toda la entrada en el localizador, permitiendo que las entradas se desplacen a la derecha de la pantalla. Se puede acceder a esta información presionando la tecla de flecha derecha.
Si prefiere truncar el resultado, insertar un elipses donde se eliminó la información, puede usar la opción --no-full:
journalctl --no-full
. . .
Feb 04 20:54:13 journalme sshd[937]: Failed password for root from 83.234.207.60...h2
Feb 04 20:54:13 journalme sshd[937]: Connection closed by 83.234.207.60 [preauth]
Feb 04 20:54:13 journalme sshd[937]: PAM 2 more authentication failures; logname...ot
También puede hacer lo opuesto e indicarle a journalctl que muestre toda la información, independientemente de si incluye caracteres no imprimibles. Podemos hacerlo con el indicador -a:
journalctl -a
Resultado a la salida estándar
Por defecto, journalctl muestra el resultado en un localizador para un uso más sencillo. Sin embargo, si está planeando procesar los datos con herramientas de manipulación de texto, es probable que quiera poder mostrar un resultado estándar.
Puede hacer esto con la opción --no-pager:
journalctl --no-pager
Se puede canalizar inmediatamente a una utilidad de procesamiento o redireccionar a un archivo en el disco, dependiendo de sus necesidades.
Formatos de resultado
Si está procesando las entradas del diario, como se mencionó anteriormente, es probable que le resulte más fácil analizar los datos si están en un formato más fácil de usar. Afortunadamente, el diario puede mostrarse en varios formatos según sea necesario. Puede hacerlo usando la opción -o con un especificador de formato.
Por ejemplo, puede mostrar las entradas del diario en JSON escribiendo lo siguiente:
journalctl -b -u nginx -o json
{ "__CURSOR" : "s=13a21661cf4948289c63075db6c25c00;i=116f1;b=81b58db8fd9046ab9f847ddb82a2fa2d;m=19f0daa;t=50e33c33587ae;x=e307daadb4858635", "__REALTIME_TIMESTAMP" : "1422990364739502", "__MONOTONIC_TIMESTAMP" : "27200938", "_BOOT_ID" : "81b58db8fd9046ab9f847ddb82a2fa2d", "PRIORITY" : "6", "_UID" : "0", "_GID" : "0", "_CAP_EFFECTIVE" : "3fffffffff", "_MACHINE_ID" : "752737531a9d1a9c1e3cb52a4ab967ee", "_HOSTNAME" : "desktop", "SYSLOG_FACILITY" : "3", "CODE_FILE" : "src/core/unit.c", "CODE_LINE" : "1402", "CODE_FUNCTION" : "unit_status_log_starting_stopping_reloading", "SYSLOG_IDENTIFIER" : "systemd", "MESSAGE_ID" : "7d4958e842da4a758f6c1cdc7b36dcc5", "_TRANSPORT" : "journal", "_PID" : "1", "_COMM" : "systemd", "_EXE" : "/usr/lib/systemd/systemd", "_CMDLINE" : "/usr/lib/systemd/systemd", "_SYSTEMD_CGROUP" : "/", "UNIT" : "nginx.service", "MESSAGE" : "Starting A high performance web server and a reverse proxy server...", "_SOURCE_REALTIME_TIMESTAMP" : "1422990364737973" }
. . .
Eso es útil para el análisis sintáctico con utilidades. Puede usar el formato json-pretty para obtener un mejor manejo de la estructura de datos antes de transmitirla al consumidor JSON:
journalctl -b -u nginx -o json-pretty
{
"__CURSOR" : "s=13a21661cf4948289c63075db6c25c00;i=116f1;b=81b58db8fd9046ab9f847ddb82a2fa2d;m=19f0daa;t=50e33c33587ae;x=e307daadb4858635",
"__REALTIME_TIMESTAMP" : "1422990364739502",
"__MONOTONIC_TIMESTAMP" : "27200938",
"_BOOT_ID" : "81b58db8fd9046ab9f847ddb82a2fa2d",
"PRIORITY" : "6",
"_UID" : "0",
"_GID" : "0",
"_CAP_EFFECTIVE" : "3fffffffff",
"_MACHINE_ID" : "752737531a9d1a9c1e3cb52a4ab967ee",
"_HOSTNAME" : "desktop",
"SYSLOG_FACILITY" : "3",
"CODE_FILE" : "src/core/unit.c",
"CODE_LINE" : "1402",
"CODE_FUNCTION" : "unit_status_log_starting_stopping_reloading",
"SYSLOG_IDENTIFIER" : "systemd",
"MESSAGE_ID" : "7d4958e842da4a758f6c1cdc7b36dcc5",
"_TRANSPORT" : "journal",
"_PID" : "1",
"_COMM" : "systemd",
"_EXE" : "/usr/lib/systemd/systemd",
"_CMDLINE" : "/usr/lib/systemd/systemd",
"_SYSTEMD_CGROUP" : "/",
"UNIT" : "nginx.service",
"MESSAGE" : "Starting A high performance web server and a reverse proxy server...",
"_SOURCE_REALTIME_TIMESTAMP" : "1422990364737973"
}
. . .
Se pueden usar los siguientes formatos para la visualización:
cat: Muestra solo el campo de mensaje.
export: Formato binario adecuado para transferir o hacer copias de seguridad.
json: JSON estándar con una entrada por línea.
json-pretty: JSON formateado para una mejor legibilidad humana
json-sse: Resultado formateado JSON envuelto para hacer que el evento enviado por servidor sea compatible
short: El resultado de estilo syslog predeterminado
short-iso: El formato predeterminado aumentado para mostrar las marcas de tiempo del reloj de pared ISO 8601.
short-monotonic: El formato predeterminado con marcas de tiempo monotónicas.
short-precise: El formato predeterminado con precisión de microsegundos.
verbose: Muestra todos los campos del diario disponibles para la entrada, incluidos los que suelen estar ocultos internamente.
Estas opciones le permiten mostrar las entradas del diario en el formato que mejor se adapte a sus necesidades actuales.
Supervisión activa de procesos
El comando journalctl imita la cantidad de administradores que utilizan tail para supervisar la actividad activa o reciente. Esta funcionalidad está incorporada en journalctl, lo que le permite acceder a estas funciones sin necesidad de recurrir a otra herramienta.
Cómo mostrar los registros recientes
Para mostrar una cantidad determinada de registros, puede usar la opción -n, que funciona exactamente igual que tail -n.
Por defecto, se mostrarán las 10 entradas más recientes:
journalctl -n
Puede especificar el número de entradas que desea ver agregando un número después de -n:
journalctl -n 20
Cómo hacer un seguimiento de los registros
Para seguir activamente los registros a medida que se escriben, puede usar el indicador -f. Una vez más, esto funciona de la manera prevista si tiene experiencia usando tail -f:
journalctl -f
Mantenimiento del diario
Es posible que se esté preguntando sobre el costo de almacenar todos los datos que hemos visto hasta ahora. Además, puede que le interese limpiar algunos registros antiguos y liberar espacio.
Cómo encontrar el uso actual de disco
Puede averiguar la cantidad de espacio que el diario está ocupando actualmente en el disco usando la opción el indicador --disk-usage:
journalctl --disk-usage
Journals take up 8.0M on disk.
Cómo eliminar registros antiguos
Si desea reducir su diario, puede hacerlo de dos distintas formas (disponibles en la versión 218 y posterior de systemd).
Si usa la opción --vacuum-size, puede reducir su diario indicando un tamaño. Esto eliminará las entradas antiguas hasta que el espacio total del diario ocupado en el disco sea del tamaño solicitado:
sudo journalctl --vacuum-size=1G
Otra forma de reducir el diario es proporcionar un tiempo límite con la opción --vacuum-time. Cualquier entrada que sobrepase ese límite de tiempo será eliminada. Esto le permite mantener las entradas que se han creado después de un tiempo específico.
Por ejemplo, para guardar las entradas del último año, puede escribir lo siguiente:
sudo journalctl --vacuum-time=1years
Cómo limitar la expansión del diario
Puede configurar su servidor para que ponga límites sobre cantidad de espacio que puede ocupar el diario. Puede hacer esto editando el archivo /etc/systemd/journald.conf
Puede usar los siguientes elementos para limitar la expansión del diario:
SystemMaxUse=: especifica el espacio máximo de disco que puede usar el diario en el almacenamiento persistente.
SystemKeepFree=: especifica la cantidad de espacio que el diario debe dejar libre al añadir entradas del diario al almacenamiento persistente.
SystemMaxFileSize=: controla el tamaño que pueden alcanzar los archivos individuales del diario en el almacenamiento persistente antes de rotar.
RuntimeMaxUse=: especifica el espacio máximo de disco que puede usarse en el almacenamiento volátil (dentro del sistema de archivos /run).
RuntimeKeepFree=: especifica la cantidad de espacio que debe reservarse para otros usos al escribir datos en el almacenamiento volátil (dentro del sistema de archivos /run).
RuntimeMaxFileSize=: especifica la cantidad de espacio que puede ocupar un archivo de diario individual en el almacenamiento volátil (dentro del sistema de archivos /run) antes de rotar.
Al establecer estos valores, puede controlar la forma en que journald utiliza y preserva el espacio en su servidor. Tenga en cuenta que SystemMaxFileSize y RuntimeMaxFileSize orientarán los archivos para llegar a los límites indicados. Es importante recordar esto al interpretar el recuento de archivos después de una operación vaciado.
Conclusión
Como puede ver, el diario systemd es increíblemente útil para recopilar y administrar los datos de su sistema y aplicación. Su flexibilidad proviene, en mayor parte, de los amplios metadatos registrados automáticamente y del carácter centralizado del registro. El comando journalctl hace que sea fácil aprovechar las funciones avanzadas del diario, realizar amplios análisis y depurar de forma relacional los diferentes componentes de la aplicación.

29
Linux/kernels Oracle.txt Normal file
View File

@ -0,0 +1,29 @@
Check available kernels
sudo rpm -qa kernel*
Listing the kernels in the /boot directory.
sudo ls -l /boot/vmlinuz*
Using the grubby command on specific kernels or using the ALL option.
sudo grubby --info /boot/vmlinuz-4.18.0*
sudo grubby --info=ALL
Check the current default kernel
sudo grubby --default-kernel
To check which kernel is currently running on a system, run:
sudo uname -r
Change the default kernel
grubby --set-default /boot/vmlinuz-5.2.14-1937.el8uek.x86_64
Change kernel command line boot parameters
Use the --update-kernel option to update a kenel entry in combination with --args to add new arguments or --remove-arguments to remove existing arguments. Multiple arguments can be specified for each option in a quoted space-separated list. You can add and remove arguments in the same operation.
To update a specific kernel, provide the --update-kernel option with the full path to the kernel that you wish to update. To update all kernel entries to use a specific kernel boot argument, you can set --update-kernel=ALL.
You can update all kernel entries to change the loglevel and LANG arguments:
grubby --update-kernel=ALL --args "loglevel=3,LANG=en_GB.UTF-8"
Use the grubby info=ALL command to check that the change is implemented across kernels:
grubby --info=ALL

71
Linux/linux network load balancing.txt Normal file
View File

@ -0,0 +1,71 @@
Getting started (http://www.sourceforge.net/projects/lnlb)
Verba docent, exempla trahunt. So before starting talk about this project I'll spend some words demostrating how could all this stuff be used.
Imagine a 3 Linux boxes (let's call them clu1, clu2 and clu3). Each box has its own IP address ( and MAC address of course).
Let's assume:
clu1: IP Addr: 1.2.3.11 - MAC (00:00:01:01:01:01)
clu2: IP Addr: 1.2.3.12 - MAC (00:00:02:02:02:02)
clu3: IP Addr: 1.2.3.13 - MAC (00:00:03:03:03:03)
Each box runs an apache webserver. All the boxes shares the same data (e.g. via an nfs share, a SAN,...) and host the same domains. So reaching http://clu1/~fred/ or http://clu2/~fred/ or http://clu3/~fred/ produces the same result.
The goal is to group clu1 clu2 and clu3 into a cluster, and let them reply to a common IP addr... all without using a proxy, nor NAT, nor strange dns techniques.
All you have to do so is:
Downloading and installing lnlb on each machine. After you've done, simply log on each box and simply type:
# modprobe lnlb && modprobe lnlb_mod_default
# lnlbctl addif 1.2.3.10 eth0
<Now, this is what happens if we do an ipconfig>
# ifconfig
> eth0 Link encap:Ethernet HWaddr 00:02:A5:13:B9:48
> inet addr:1.2.3.11 Bcast:1.2.3.255 Mask:255.255.255.0
> ....
>
> nlb0 Link encap:UNKNOWN HWaddr 02:00:01:02:03:0A
> inet addr:1.2.3.10 Mask: 255.255.255.255
Once you've done, just point your dns server to cluster IP addr (1.2.3.10 in the example)... the driver will do the rest and incoming connections will be distributed among clu1 clu2 and clu3.
Could you ever think it simpler? :)
Now, let's spend some words about how the magic is done.
(Some knowledge of IP protocol and Ethernet networks is required at this point)
When an host in the network (note: routers are network hosts too, so all this stuff will work with external requests coming from the internet with no problems, no worry) needs to send an IP datagram to the cluster IP address, first of all it sends an ARP request asking the MAC for that IP. At this point the driver will mangle arp replies and al the nodes will reply a (shared) "fake" MAC address.
The result is that traffic directed to the cluster is broadcasted on the network, since the switch will never learn the port associated to that MAC (yep here comes the bad news, the only price you pay for all this, is that inbound traffic is flooded to all the hosts... see remarks).
Every 7 seconds (this value can be changed during module loading adding the "heartbeat_interval=N" parameter to the "modprobe lnlb" command) each node sends an heartbeat to the rest of the cluster through an ethernet frame [proto 0x8870].
So every 7 seconds the nodes will synchronize and, during this convergence phase, every node knows weight of other nodes.
Once this is done, balancing of incoming traffic can start: each node determines whether to deliver (to the virtual interface) via a weigthed hash table mechanism: the higher weight a node has, the less incoming traffic it gets.
I'm quite sure that at this point you're probably wondering: what's weight... how is node weight estimated ?
weight. In the "driver world" node weight is strictly an unsigned int (1-65535 range accepted)... all the balancing process uses this value to distribute incoming traffic.
Let's now see how this value is estimated:
By default the driver uses system load average value.. but you can change this weight source to:
5 min Load Avg: (# lnlbctl weight_mode nlb0 loadavg5 )
15 min Load Avg (# lnlbctl weight_mode nlb0 loadavg15 )
Free memory %: (# lnlbctl weight_mode nlb0 freemem )
If these sources do not satisfy your needs (and here comes the good news) you can set the weight source to "manual" (#lnlbctl weight_mode nlb0 manual ) and feed the driver , e.g. through a crontab script that every 7 seconds (or more) does the following:
# lnlbctl set_weight nlb0 X (where X is a value between 1 and 65535)
Eventually you can replace x with the "stdin" word (without quotes) and push the value into stdin instead of command line.
Connection tracking
Since ... the driver ships with a connection tracking module (lnlb_mod_default... btw the driver will not work without this module).
Once a remote host (read " remote IP") sends a request to the cluster and its datagrams are delivered to a node, its session will be tracked and all following datagrams coming from that IP address will be sent to the same node.
Sessions are marked as expired after 30 mins of inactivity (no datagram received from the remote IP). This value can be altered when loading the lnlb_mod_default module adding a "conntrack_idle_timeout=X" parameter to the modprobe (value in seconds).
If you need any other particular session tracking method you can reimplement the default handler, or write a specific transport handler... see developers sections for more info.
Remarks
As told before, the main disadvantage is that inbound traffic is flooded over the network.
First of all I suggest you to group all nodes of a cluster in a separate VLAN in order to keep flooding limited to cluster nodes (I'm working on a multicast mode in order to use IGMP snooping to keep broadcasting limited to cluster withoud having to configure a VLAN... stay tuned).
Second... It's clear that this project could be (at least I hope so) mainly useful in context that requires few inbound traffic capabilities and (but more outbound)... (this sould be perfectly fine when balancing web services for instance).
Just to do a numeric example.. if you have a cluster made up by 4 nodes with a 100Mbit/s ethernet connection, the inbound capabilities of the cluster will be still 100Mbit/s total, but, since each node sends outbound traffic with its own MAC, outbound capabilities will be 4x100 Mbit/s.
That's all

790
Linux/linux workstation security.txt Normal file
View File

@ -0,0 +1,790 @@
# Linux workstation security checklist
This is a set of recommendations used by the Linux Foundation for their systems
administrators. All of LF employees are remote workers and we use this set of
guidelines to ensure that a sysadmin's system passes core security requirements
in order to reduce the risk of it becoming an attack vector against the rest
of our infrastructure.
Even if your systems administrators are not remote workers, chances are that
they perform a lot of their work either from a portable laptop in a work
environment, or set up their home systems to access the work infrastructure
for after-hours/emergency support. In either case, you can adapt this set of
recommendations to suit your environment.
This, by no means, is an exhaustive "workstation hardening" document, but
rather an attempt at a set of baseline recommendations to avoid most glaring
security errors without introducing too much inconvenience. You may read this
document and think it is way too paranoid, while someone else may think this
barely scratches the surface. Security is just like driving on the highway --
anyone going slower than you is an idiot, while anyone driving faster than you
is a crazy person. These guidelines are merely a basic set of core safety
rules that is neither exhaustive, nor a replacement for experience, vigilance,
and common sense.
Each section is split into two areas:
- The checklist that can be adapted to your project's needs
- Free-form list of considerations that explain what dictated these decisions
## Severity levels
The items in each checklist include the severity level, which we hope will help
guide your decision:
- _(CRITICAL)_ items should definitely be high on the consideration list.
If not implemented, they will introduce high risks to your workstation
security.
- _(MODERATE)_ items will improve your security posture, but are less
important, especially if they interfere too much with your workflow.
- _(LOW)_ items may improve the overall security, but may not be worth the
convenience trade-offs.
- _(PARANOID)_ is reserved for items we feel will dramatically improve your
workstation security, but will probably require a lot of adjustment to the
way you interact with your operating system.
Remember, these are only guidelines. If you feel these severity levels do not
reflect your project's commitment to security, you should adjust them as you
see fit.
## Choosing the right hardware
We do not mandate that our admins use a specific vendor or a specific model, so
this section addresses core considerations when choosing a work system.
### Checklist
- [ ] System supports SecureBoot _(CRITICAL)_
- [ ] System has no firewire, thunderbolt or ExpressCard ports _(MODERATE)_
- [ ] System has a TPM chip _(LOW)_
### Considerations
#### SecureBoot
Despite its controversial nature, SecureBoot offers prevention against many
attacks targeting workstations (Rootkits, "Evil Maid," etc), without
introducing too much extra hassle. It will not stop a truly dedicated attacker,
plus there is a pretty high degree of certainty that state security agencies
have ways to defeat it (probably by design), but having SecureBoot is better
than having nothing at all.
Alternatively, you may set up [Anti Evil Maid][1] which offers a more
wholesome protection against the type of attacks that SecureBoot is supposed
to prevent, but it will require more effort to set up and maintain.
#### Firewire, thunderbolt, and ExpressCard ports
Firewire is a standard that, by design, allows any connecting device full
direct memory access to your system ([see Wikipedia][2]). Thunderbolt and
ExpressCard are guilty of the same, though some later implementations of
Thunderbolt attempt to limit the scope of memory access. It is best if the
system you are getting has none of these ports, but it is not critical, as
they usually can be turned off via UEFI or disabled in the kernel itself.
#### TPM Chip
Trusted Platform Module (TPM) is a crypto chip bundled with the motherboard
separately from the core processor, which can be used for additional platform
security (such as to store full-disk encryption keys), but is not normally used
for day-to-day workstation operation. At best, this is a nice-to-have, unless
you have a specific need to use TPM for your workstation security.
## Pre-boot environment
This is a set of recommendations for your workstation before you even start
with OS installation.
### Checklist
- [ ] UEFI boot mode is used (not legacy BIOS) _(CRITICAL)_
- [ ] Password is required to enter UEFI configuration _(CRITICAL)_
- [ ] SecureBoot is enabled _(CRITICAL)_
- [ ] UEFI-level password is required to boot the system _(LOW)_
### Considerations
#### UEFI and SecureBoot
UEFI, with all its warts, offers a lot of goodies that legacy BIOS doesn't,
such as SecureBoot. Most modern systems come with UEFI mode on by default.
Make sure a strong password is required to enter UEFI configuration mode. Pay
attention, as many manufacturers quietly limit the length of the password you
are allowed to use, so you may need to choose high-entropy short passwords vs.
long passphrases (see below for more on passphrases).
Depending on the Linux distribution you decide to use, you may or may not have
to jump through additional hoops in order to import your distribution's
SecureBoot key that would allow you to boot the distro. Many distributions have
partnered with Microsoft to sign their released kernels with a key that is
already recognized by most system manufacturers, therefore saving you the
trouble of having to deal with key importing.
As an extra measure, before someone is allowed to even get to the boot
partition and try some badness there, let's make them enter a password. This
password should be different from your UEFI management password, in order to
prevent shoulder-surfing. If you shut down and start a lot, you may choose to
not bother with this, as you will already have to enter a LUKS passphrase and
this will save you a few extra keystrokes.
## Distro choice considerations
Chances are you'll stick with a fairly widely-used distribution such as Fedora,
Ubuntu, Arch, Debian, or one of their close spin-offs. In any case, this is
what you should consider when picking a distribution to use.
### Checklist
- [ ] Has a robust MAC/RBAC implementation (SELinux/AppArmor/Grsecurity) _(CRITICAL)_
- [ ] Publishes security bulletins _(CRITICAL)_
- [ ] Provides timely security patches _(CRITICAL)_
- [ ] Provides cryptographic verification of packages _(CRITICAL)_
- [ ] Fully supports UEFI and SecureBoot _(CRITICAL)_
- [ ] Has robust native full disk encryption support _(CRITICAL)_
### Considerations
#### SELinux, AppArmor, and GrSecurity/PaX
Mandatory Access Controls (MAC) or Role-Based Access Controls (RBAC) are an
extension of the basic user/group security mechanism used in legacy POSIX
systems. Most distributions these days either already come bundled with a
MAC/RBAC implementation (Fedora, Ubuntu), or provide a mechanism to add it via
an optional post-installation step (Gentoo, Arch, Debian). Obviously, it is
highly advised that you pick a distribution that comes pre-configured with a
MAC/RBAC system, but if you have strong feelings about a distribution that
doesn't have one enabled by default, do plan to configure it
post-installation.
Distributions that do not provide any MAC/RBAC mechanisms should be strongly
avoided, as traditional POSIX user- and group-based security should be
considered insufficient in this day and age. If you would like to start out
with a MAC/RBAC workstation, AppArmor and PaX are generally considered easier
to learn than SELinux. Furthermore, on a workstation, where there are few or
no externally listening daemons, and where user-run applications pose the
highest risk, GrSecurity/PaX will _probably_ offer more security benefits than
SELinux.
#### Distro security bulletins
Most of the widely used distributions have a mechanism to deliver security
bulletins to their users, but if you are fond of something esoteric, check
whether the developers have a documented mechanism of alerting the users about
security vulnerabilities and patches. Absence of such mechanism is a major
warning sign that the distribution is not mature enough to be considered for a
primary admin workstation.
#### Timely and trusted security updates
Most of the widely used distributions deliver regular security updates, but is
worth checking to ensure that critical package updates are provided in a
timely fashion. Avoid using spin-offs and "community rebuilds" for this
reason, as they routinely delay security updates due to having to wait for the
upstream distribution to release it first.
You'll be hard-pressed to find a distribution that does not use cryptographic
signatures on packages, updates metadata, or both. That being said, fairly
widely used distributions have been known to go for years before introducing
this basic security measure (Arch, I'm looking at you), so this is a thing
worth checking.
#### Distros supporting UEFI and SecureBoot
Check that the distribution supports UEFI and SecureBoot. Find out whether it
requires importing an extra key or whether it signs its boot kernels with a key
already trusted by systems manufacturers (e.g. via an agreement with
Microsoft). Some distributions do not support UEFI/SecureBoot but offer
alternatives to ensure tamper-proof or tamper-evident boot environments
([Qubes-OS][3] uses Anti Evil Maid, mentioned earlier). If a distribution
doesn't support SecureBoot and has no mechanisms to prevent boot-level attacks,
look elsewhere.
#### Full disk encryption
Full disk encryption is a requirement for securing data at rest, and is
supported by most distributions. As an alternative, systems with
self-encrypting hard drives may be used (normally implemented via the on-board
TPM chip) and offer comparable levels of security plus faster operation, but at
a considerably higher cost.
## Distro installation guidelines
All distributions are different, but here are general guidelines:
### Checklist
- [ ] Use full disk encryption (LUKS) with a robust passphrase _(CRITICAL)_
- [ ] Make sure swap is also encrypted _(CRITICAL)_
- [ ] Require a password to edit bootloader (can be same as LUKS) _(CRITICAL)_
- [ ] Set up a robust root password (can be same as LUKS) _(CRITICAL)_
- [ ] Use an unprivileged account, part of administrators group _(CRITICAL)_
- [ ] Set up a robust user-account password, different from root _(CRITICAL)_
### Considerations
#### Full disk encryption
Unless you are using self-encrypting hard drives, it is important to configure
your installer to fully encrypt all the disks that will be used for storing
your data and your system files. It is not sufficient to simply encrypt the
user directory via auto-mounting cryptfs loop files (I'm looking at you, older
versions of Ubuntu), as this offers no protection for system binaries or swap,
which is likely to contain a slew of sensitive data. The recommended
encryption strategy is to encrypt the LVM device, so only one passphrase is
required during the boot process.
The `/boot` partition will always remain unencrypted, as the bootloader needs
to be able to actually boot the kernel before invoking LUKS/dm-crypt. The
kernel image itself should be protected against tampering with a cryptographic
signature checked by SecureBoot.
In other words, `/boot` should always be the only unencrypted partition on your
system.
#### Choosing good passphrases
Modern Linux systems have no limitation of password/passphrase length, so the
only real limitation is your level of paranoia and your stubbornness. If you
boot your system a lot, you will probably have to type at least two different
passwords: one to unlock LUKS, and another one to log in, so having long
passphrases will probably get old really fast. Pick passphrases that are 2-3
words long, easy to type, and preferably from rich/mixed vocabularies.
Examples of good passphrases (yes, you can use spaces):
- nature abhors roombas
- 12 in-flight Jebediahs
- perdon, tengo flatulence
You can also stick with non-vocabulary passwords that are at least 10-12
characters long, if you prefer that to typing passphrases.
Unless you have concerns about physical security, it is fine to write down your
passphrases and keep them in a safe place away from your work desk.
#### Root, user passwords and the admin group
We recommend that you use the same passphrase for your root password as you
use for your LUKS encryption (unless you share your laptop with other trusted
people who should be able to unlock the drives, but shouldn't be able to
become root). If you are the sole user of the laptop, then having your root
password be different from your LUKS password has no meaningful security
advantages. Generally, you can use the same passphrase for your UEFI
administration, disk encryption, and root account -- knowing any of these will
give an attacker full control of your system anyway, so there is little
security benefit to have them be different on a single-user workstation.
You should have a different, but equally strong password for your regular user
account that you will be using for day-to-day tasks. This user should be member
of the admin group (e.g. `wheel` or similar, depending on the distribution),
allowing you to perform `sudo` to elevate privileges.
In other words, if you are the sole user on your workstation, you should have 2
distinct, robust, equally strong passphrases you will need to remember:
**Admin-level**, used in the following locations:
- UEFI administration
- Bootloader (GRUB)
- Disk encryption (LUKS)
- Workstation admin (root user)
**User-level**, used for the following:
- User account and sudo
- Master password for the password manager
All of them, obviously, can be different if there is a compelling reason.
## Post-installation hardening
Post-installation security hardening will depend greatly on your distribution
of choice, so it is futile to provide detailed instructions in a general
document such as this one. However, here are some steps you should take:
### Checklist
- [ ] Globally disable firewire and thunderbolt modules _(CRITICAL)_
- [ ] Check your firewalls to ensure all incoming ports are filtered _(CRITICAL)_
- [ ] Make sure root mail is forwarded to an account you check _(CRITICAL)_
- [ ] Check to ensure sshd service is disabled by default _(MODERATE)_
- [ ] Set up an automatic OS update schedule, or update reminders _(MODERATE)_
- [ ] Configure the screensaver to auto-lock after a period of inactivity _(MODERATE)_
- [ ] Set up logwatch _(MODERATE)_
- [ ] Install and use rkhunter _(LOW)_
- [ ] Install an Intrusion Detection System _(PARANOID)_
### Considerations
#### Blacklisting modules
To blacklist a firewire and thunderbolt modules, add the following lines to a
file in `/etc/modprobe.d/blacklist-dma.conf`:
blacklist firewire-core
blacklist thunderbolt
The modules will be blacklisted upon reboot. It doesn't hurt doing this even if
you don't have these ports (but it doesn't do anything either).
#### Root mail
By default, root mail is just saved on the system and tends to never be read.
Make sure you set your `/etc/aliases` to forward root mail to a mailbox that
you actually read, otherwise you may miss important system notifications and
reports:
# Person who should get root's mail
root: bob@example.com
Run `newaliases` after this edit and test it out to make sure that it actually
gets delivered, as some email providers will reject email coming in from
nonexistent or non-routable domain names. If that is the case, you will need to
play with your mail forwarding configuration until this actually works.
#### Firewalls, sshd, and listening daemons
The default firewall settings will depend on your distribution, but many of
them will allow incoming `sshd` ports. Unless you have a compelling legitimate
reason to allow incoming ssh, you should filter that out and disable the `sshd`
daemon.
systemctl disable sshd.service
systemctl stop sshd.service
You can always start it temporarily if you need to use it.
In general, your system shouldn't have any listening ports apart from
responding to ping. This will help safeguard you against network-level 0-day
exploits.
#### Automatic updates or notifications
It is recommended to turn on automatic updates, unless you have a very good
reason not to do so, such as fear that an automatic update would render your
system unusable (it's happened in the past, so this fear is not unfounded). At
the very least, you should enable automatic notifications of available updates.
Most distributions already have this service automatically running for you, so
chances are you don't have to do anything. Consult your distribution
documentation to find out more.
You should apply all outstanding errata as soon as possible, even if something
isn't specifically labeled as "security update" or has an associated CVE code.
All bugs have the potential of being security bugs and erring on the side of
newer, unknown bugs is _generally_ a safer strategy than sticking with old,
known ones.
#### Watching logs
You should have a keen interest in what happens on your system. For this
reason, you should install `logwatch` and configure it to send nightly activity
reports of everything that happens on your system. This won't prevent a
dedicated attacker, but is a good safety-net feature to have in place.
Note, that many systemd distros will no longer automatically install a syslog
server that `logwatch` needs (due to systemd relying on its own journal), so
you will need to install and enable `rsyslog` to make sure your `/var/log` is
not empty before logwatch will be of any use.
#### Rkhunter and IDS
Installing `rkhunter` and an intrusion detection system (IDS) like `aide` or
`tripwire` will not be that useful unless you actually understand how they work
and take the necessary steps to set them up properly (such as, keeping the
databases on external media, running checks from a trusted environment,
remembering to refresh the hash databases after performing system updates and
configuration changes, etc). If you are not willing to take these steps and
adjust how you do things on your own workstation, these tools will introduce
hassle without any tangible security benefit.
We do recommend that you install `rkhunter` and run it nightly. It's fairly
easy to learn and use, and though it will not deter a sophisticated attacker,
it may help you catch your own mistakes.
## Personal workstation backups
Workstation backups tend to be overlooked or done in a haphazard, often unsafe
manner.
### Checklist
- [ ] Set up encrypted workstation backups to external storage _(CRITICAL)_
- [ ] Use zero-knowledge backup tools for cloud backups _(MODERATE)_
### Considerations
#### Full encrypted backups to external storage
It is handy to have an external hard drive where one can dump full backups
without having to worry about such things like bandwidth and upstream speeds
(in this day and age most providers still offer dramatically asymmetric
upload/download speeds). Needless to say, this hard drive needs to be in itself
encrypted (again, via LUKS), or you should use a backup tool that creates
encrypted backups, such as `duplicity` or its GUI companion, `deja-dup`. I
recommend using the latter with a good randomly generated passphrase, stored in
your password manager. If you travel with your laptop, leave this drive at home
to have something to come back to in case your laptop is lost or stolen.
In addition to your home directory, you should also back up `/etc` and
`/var/log` for various forensic purposes.
Above all, avoid copying your home directory onto any unencrypted storage, even
as a quick way to move your files around between systems, as you will most
certainly forget to erase it once you're done, exposing potentially private or
otherwise security sensitive data to snooping hands -- especially if you keep
that storage media in the same bag with your laptop.
#### Selective zero-knowledge backups off-site
Off-site backups are also extremely important and can be done either to your
employer, if they offer space for it, or to a cloud provider. You can set up a
separate duplicity/deja-dup profile to only include most important files in
order to avoid transferring huge amounts of data that you don't really care to
back up off-site (internet cache, music, downloads, etc).
Alternatively, you can use a zero-knowledge backup tool, such as
[SpiderOak][5], which offers an excellent Linux GUI tool and has additional
useful features such as synchronizing content between multiple systems and
platforms.
## Best practices
What follows is a curated list of best practices that we think you should
adopt. It is most certainly non-exhaustive, but rather attempts to offer
practical advice that strikes a workable balance between security and overall
usability.
### Browsing
There is no question that the web browser will be the piece of software with
the largest and the most exposed attack surface on your system. It is a tool
written specifically to download and execute untrusted, frequently hostile
code. It attempts to shield you from this danger by employing multiple
mechanisms such as sandboxes and code sanitization, but they have all been
previously defeated on multiple occasions. You should learn to approach
browsing websites as the most insecure activity you'll engage in on any given
day.
There are several ways you can reduce the impact of a compromised browser, but
the truly effective ways will require significant changes in the way you
operate your workstation.
#### 1: Use two different browsers
This is the easiest to do, but only offers minor security benefits. Not all
browser compromises give an attacker full unfettered access to your system --
sometimes they are limited to allowing one to read local browser storage,
steal active sessions from other tabs, capture input entered into the browser,
etc. Using two different browsers, one for work/high security sites, and
another for everything else will help prevent minor compromises from giving
attackers access to the whole cookie jar. The main inconvenience will be the
amount of memory consumed by two different browser processes.
Here's what we recommend:
##### Firefox for work and high security sites
Use Firefox to access work-related sites, where extra care should be taken to
ensure that data like cookies, sessions, login information, keystrokes, etc,
should most definitely not fall into attackers' hands. You should NOT use
this browser for accessing any other sites except select few.
You should install the following Firefox add-ons:
- [ ] NoScript _(CRITICAL)_
- NoScript prevents active content from loading, except from user
whitelisted domains. It is a great hassle to use with your default browser
(though offers really good security benefits), so we recommend only
enabling it on the browser you use to access work-related sites.
- [ ] Privacy Badger _(CRITICAL)_
- EFF's Privacy Badger will prevent most external trackers and ad platforms
from being loaded, which will help avoid compromises on these tracking
sites from affecting your browser (trackers and ad sites are very commonly
targeted by attackers, as they allow rapid infection of thousands of
systems worldwide).
- [ ] HTTPS Everywhere _(CRITICAL)_
- This EFF-developed Add-on will ensure that most of your sites are accessed
over a secure connection, even if a link you click is using http:// (great
to avoid a number of attacks, such as [SSL-strip][7]).
- [ ] Certificate Patrol _(MODERATE)_
- This tool will alert you if the site you're accessing has recently changed
their TLS certificates -- especially if it wasn't nearing expiration dates
or if it is now using a different certification authority. It helps
alert you if someone is trying to man-in-the-middle your connection,
but generates a lot of benign false-positives.
You should leave Firefox as your default browser for opening links, as
NoScript will prevent most active content from loading or executing.
##### Chrome/Chromium for everything else
Chromium developers are ahead of Firefox in adding a lot of nice security
features (at least [on Linux][6]), such as seccomp sandboxes, kernel user
namespaces, etc, which act as an added layer of isolation between the sites
you visit and the rest of your system. Chromium is the upstream open-source
project, and Chrome is Google's proprietary binary build based on it (insert
the usual paranoid caution about not using it for anything you don't want
Google to know about).
It is recommended that you install **Privacy Badger** and **HTTPS Everywhere**
extensions in Chrome as well and give it a distinct theme from Firefox to
indicate that this is your "untrusted sites" browser.
#### 2: Use two different browsers, one inside a dedicated VM
This is a similar recommendation to the above, except you will add an extra
step of running Chrome inside a dedicated VM that you access via a fast
protocol, allowing you to share clipboards and forward sound events (e.g.
Spice or RDP). This will add an excellent layer of isolation between the
untrusted browser and the rest of your work environment, ensuring that
attackers who manage to fully compromise your browser will then have to
additionally break out of the VM isolation layer in order to get to the rest
of your system.
This is a surprisingly workable configuration, but requires a lot of RAM and
fast processors that can handle the increased load. It will also require an
important amount of dedication on the part of the admin who will need to
adjust their work practices accordingly.
#### 3: Fully separate your work and play environments via virtualization
See [Qubes-OS project][3], which strives to provide a high-security
workstation environment via compartmentalizing your applications into separate
fully isolated VMs.
### Password managers
#### Checklist
- [ ] Use a password manager _(CRITICAL_)
- [ ] Use unique passwords on unrelated sites _(CRITICAL)_
- [ ] Use a password manager that supports team sharing _(MODERATE)_
- [ ] Use a separate password manager for non-website accounts _(PARANOID)_
#### Considerations
Using good, unique passwords should be a critical requirement for every member
of your team. Credential theft is happening all the time -- either via
compromised computers, stolen database dumps, remote site exploits, or any
number of other means. No credentials should ever be reused across sites,
especially for critical applications.
##### In-browser password manager
Every browser has a mechanism for saving passwords that is fairly secure and
can sync with vendor-maintained cloud storage while keeping the data encrypted
with a user-provided passphrase. However, this mechanism has important
disadvantages:
1. It does not work across browsers
2. It does not offer any way of sharing credentials with team members
There are several well-supported, free-or-cheap password managers that are
well-integrated into multiple browsers, work across platforms, and offer
group sharing (usually as a paid service). Solutions can be easily found via
search engines.
##### Standalone password manager
One of the major drawbacks of any password manager that comes integrated with
the browser is the fact that it's part of the application that is most likely
to be attacked by intruders. If this makes you uncomfortable (and it should),
you may choose to have two different password managers -- one for websites
that is integrated into your browser, and one that runs as a standalone
application. The latter can be used to store high-risk credentials such as
root passwords, database passwords, other shell account credentials, etc.
It may be particularly useful to have such tool for sharing superuser account
credentials with other members of your team (server root passwords, ILO
passwords, database admin passwords, bootloader passwords, etc).
A few tools can help you:
- [KeePassX][8], which improves team sharing in version 2
- [Pass][9], which uses text files and PGP and integrates with git
- [Django-Pstore][10], which uses GPG to share credentials between admins
- [Hiera-Eyaml][11], which, if you are already using Puppet for your
infrastructure, may be a handy way to track your server/service credentials
as part of your encrypted Hiera data store
### Securing SSH and PGP private keys
Personal encryption keys, including SSH and PGP private keys, are going to be
the most prized items on your workstation -- something the attackers will be
most interested in obtaining, as that would allow them to further attack your
infrastructure or impersonate you to other admins. You should take extra steps
to ensure that your private keys are well protected against theft.
#### Checklist
- [ ] Strong passphrases are used to protect private keys _(CRITICAL)_
- [ ] PGP Master key is stored on removable storage _(MODERATE)_
- [ ] Auth, Sign and Encrypt Subkeys are stored on a smartcard device _(MODERATE)_
- [ ] SSH is configured to use PGP Auth key as ssh private key _(MODERATE)_
#### Considerations
The best way to prevent private key theft is to use a smartcard to store your
encryption private keys and never copy them onto the workstation. There are
several manufacturers that offer OpenPGP capable devices:
- [Kernel Concepts][12], where you can purchase both the OpenPGP compatible
smartcards and the USB readers, should you need one.
- [Yubikey NEO][13], which offers OpenPGP smartcard functionality in addition
to many other cool features (U2F, PIV, HOTP, etc).
It is also important to make sure that the master PGP key is not stored on the
main workstation, and only subkeys are used. The master key will only be
needed when signing someone else's keys or creating new subkeys -- operations
which do not happen very frequently. You may follow [the Debian's subkeys][14]
guide to learn how to move your master key to removable storage and how to
create subkeys.
You should then configure your gnupg agent to act as ssh agent and use the
smartcard-based PGP Auth key to act as your ssh private key. We publish a
[detailed guide][15] on how to do that using either a smartcard reader or a
Yubikey NEO.
If you are not willing to go that far, at least make sure you have a strong
passphrase on both your PGP private key and your SSH private key, which will
make it harder for attackers to steal and use them.
### SELinux on the workstation
If you are using a distribution that comes bundled with SELinux (such as
Fedora), here are some recommendation of how to make the best use of it to
maximize your workstation security.
#### Checklist
- [ ] Make sure SELinux is enforcing on your workstation _(CRITICAL)_
- [ ] Never blindly run `audit2allow -M`, always check _(CRITICAL)_
- [ ] Never `setenforce 0` _(MODERATE)_
- [ ] Switch your account to SELinux user `staff_u` _(MODERATE)_
#### Considerations
SELinux is a Mandatory Access Controls (MAC) extension to core POSIX
permissions functionality. It is mature, robust, and has come a long way since
its initial roll-out. Regardless, many sysadmins to this day repeat the
outdated mantra of "just turn it off."
That being said, SELinux will have limited security benefits on the
workstation, as most applications you will be running as a user are going to
be running unconfined. It does provide enough net benefit to warrant leaving
it on, as it will likely help prevent an attacker from escalating privileges
to gain root-level access via a vulnerable daemon service.
Our recommendation is to leave it on and enforcing.
##### Never `setenforce 0`
It's tempting to use `setenforce 0` to flip SELinux into permissive mode
on a temporary basis, but you should avoid doing that. This essentially turns
off SELinux for the entire system, while what you really want is to
troubleshoot a particular application or daemon.
Instead of `setenforce 0` you should be using `semanage permissive -a
[somedomain_t]` to put only that domain into permissive mode. First, find out
which domain is causing troubles by running `ausearch`:
ausearch -ts recent -m avc
and then look for `scontext=` (source SELinux context) line, like so:
scontext=staff_u:staff_r:gpg_pinentry_t:s0-s0:c0.c1023
^^^^^^^^^^^^^^
This tells you that the domain being denied is `gpg_pinentry_t`, so if you
want to troubleshoot the application, you should add it to permissive domains:
semange permissive -a gpg_pinentry_t
This will allow you to use the application and collect the rest of the AVCs,
which you can then use in conjunction with `audit2allow` to write a local
policy. Once that is done and you see no new AVC denials, you can remove that
domain from permissive by running:
semanage permissive -d gpg_pinentry_t
##### Use your workstation as SELinux role staff_r
SELinux comes with a native implementation of roles that prohibit or grant
certain privileges based on the role associated with the user account. As an
administrator, you should be using the `staff_r` role, which will restrict
access to many configuration and other security-sensitive files, unless you
first perform `sudo`.
By default, accounts are created as `unconfined_r` and most applications you
execute will run unconfined, without any (or with only very few) SELinux
constraints. To switch your account to the `staff_r` role, run the following
command:
usermod -Z staff_u [username]
You should log out and log back in to enable the new role, at which point if
you run `id -Z`, you'll see:
staff_u:staff_r:staff_t:s0-s0:c0.c1023
When performing `sudo`, you should remember to add an extra flag to tell
SELinux to transition to the "sysadmin" role. The command you want is:
sudo -i -r sysadm_r
At which point `id -Z` will show:
staff_u:sysadm_r:sysadm_t:s0-s0:c0.c1023
**WARNING**: you should be comfortable using `ausearch` and `audit2allow`
before you make this switch, as it's possible some of your applications will
no longer work when you're running as role `staff_r`. At the time of writing,
the following popular applications are known to not work under `staff_r`
without policy tweaks:
- Chrome/Chromium
- Skype
- VirtualBox
To switch back to `unconfined_r`, run the following command:
usermod -Z unconfined_u [username]
and then log out and back in to get back into the comfort zone.
## Further reading
The world of IT security is a rabbit hole with no bottom. If you would like to
go deeper, or find out more about security features on your particular
distribution, please check out the following links:
- [Fedora Security Guide](https://docs.fedoraproject.org/en-US/Fedora/19/html/Security_Guide/index.html)
- [CESG Ubuntu Security Guide](https://www.gov.uk/government/publications/end-user-devices-security-guidance-ubuntu-1404-lts)
- [Debian Security Manual](https://www.debian.org/doc/manuals/securing-debian-howto/index.en.html)
- [Arch Linux Security Wiki](https://wiki.archlinux.org/index.php/Security)
- [Mac OSX Security](https://www.apple.com/support/security/guides/)
## License
This work is licensed under a
[Creative Commons Attribution-ShareAlike 4.0 International License][0].
[0]: http://creativecommons.org/licenses/by-sa/4.0/
[1]: https://github.com/QubesOS/qubes-antievilmaid
[2]: https://en.wikipedia.org/wiki/IEEE_1394#Security_issues
[3]: https://qubes-os.org/
[4]: https://xkcd.com/936/
[5]: https://spideroak.com/
[6]: https://code.google.com/p/chromium/wiki/LinuxSandboxing
[7]: http://www.thoughtcrime.org/software/sslstrip/
[8]: https://keepassx.org/
[9]: http://www.passwordstore.org/
[10]: https://pypi.python.org/pypi/django-pstore
[11]: https://github.com/TomPoulton/hiera-eyaml
[12]: http://shop.kernelconcepts.de/
[13]: https://www.yubico.com/products/yubikey-hardware/yubikey-neo/
[14]: https://wiki.debian.org/Subkeys
[15]: https://github.com/lfit/ssh-gpg-smartcard-config

20
Linux/listado de usuarios de un grupo especifico.txt Normal file
View File

@ -0,0 +1,20 @@
#VARIABLES EXTERNAS PARA EL COMANDO AWK
users=$(getent group users | cut -d: -f3)
#COMENZAMOS EL PROCESO DE LISTADO
sudo echo -e "-----------------------------------" > ./$HOSTNAME.listadoUsuarios
sudo echo -e "-----------------------------------" >> ./$HOSTNAME.listadoUsuarios
sudo echo -e $HOSTNAME >> ./$HOSTNAME.listadoUsuarios
sudo echo -e "-----------------------------------" >> ./$HOSTNAME.listadoUsuarios
sudo echo -e "-----------------------------------" >> ./$HOSTNAME.listadoUsuarios
#OBTENEMOS USUARIOS GRUPO users
sudo echo -e USUARIOS users >> ./$HOSTNAME.listadoUsuarios
sudo echo -e "-----------------------------------" >> ./$HOSTNAME.listadoUsuarios
sudo awk -v users=$users -F: '{if($4 == users) print $1"\t "$5}' /etc/passwd >> ./$HOSTNAME.listadoUsuarios
sudo echo -e "-----------------------------------" >> ./$HOSTNAME.listadoUsuarios
#iconv ./$HOSTNAME.listadoUsuarios -f iso-8859-1 -t utf-8 -o ./$HOSTNAME.listadoUsuarios

72
Linux/log comandos ssh y sftp.txt Normal file
View File

@ -0,0 +1,72 @@
Para guardar las sesiones ssh que se realizan en los servidores, hay que realizar los siguientes cambios:
Según la máquina es un archivo u otro
vim /etc/bash.bashrc
vim /etc/bashrc
al final del fichero añadimos:
export PROMPT_COMMAND='RETRN_VAL=$?;logger -p local6.debug "$(whoami) ${HOSTNAME}:${PWD} [$$]: $(history 1 | sed "s/^[ ]*[0-9]\+[ ]*//" ) [$RETRN_VAL]"'
creamos fichero log y cambiamos propietario y permisos:
touch /var/log/cmdhistory.log
chown syslog:adm /var/log/cmdhistory.log
chmod 640 /var/log/cmdhistory.log
Logging de sesiones SFTP
creamos fichero vim /usr/local/bin sftp-wrapper con este contenido:
#!/bin/bash
# sftpd wrapper script pre/post sesiones
#
# acciones pre sesion y logging
SOURCE_IP=${SSH_CLIENT%% *}
MSG_SESSION_START="user $LOGNAME session start from $SOURCE_IP"
logger -p local5.notice -t sftpd-wrapper -i "$MSG_SESSION_START"
# comienzo actual sesion SFTP
/usr/lib/openssh/sftp-server -f LOCAL5 -l VERBOSE
# añadimos acciones post sesion aqui
MSG_SESSION_STOP="user $LOGNAME session ended from $SOURCE_IP"
logger -p local5.notice -t sftpd-wrapper -i "$MSG_SESSION_STOP"
Cambiamos los permisos al fichero:
chmod +x /usr/local/bin/sftp-wrapper
Modificamos el fichero /etc/ssh/sshd_config:
# override default of no subsystems
#Subsystem sftp /usr/lib/openssh/sftp-server
Subsystem sftp /usr/local/bin/sftp-wrapper
Creamos el fichero /var/log/sftp.log y modificamos permisos y propietario:
touch /var/log/sftp.log
chmod 640 /var/log/sftp.log
chown syslog:adm /var/log/sftp.log
Editamos el fichero
vim /etc/rsyslog.conf y añadimos al final:
##MONITOR CMD y SFTP
local6.* /var/log/cmdhistory.log
local5.* /var/log/sftp.log
Se incluyen ambos ficheros en el logrotate de la máquina y para ello, creamos fichero /etc/logrotate.d/sftp_cmd con el contenido:
/var/log/sftp.log
/var/log/cmdhistory.log {
rotate 52
weekly
missingok
notifempty
compress
delaycompress
create 640 syslog adm
sharedscripts
postrotate
invoke-rc.d rsyslog rotate >/dev/null 2>&1 || true
endscript }
Reiniciamos servicios:
systemctl restart sshd
systemctl restart rsyslog

70
Linux/login sesiones ssh y sftp.txt Normal file
View File

@ -0,0 +1,70 @@
Para guardar las sesiones ssh que se realizan en los servidores, hay que realizar los siguientes cambios:
Según la máquina es un archivo u otro
vim /etc/bash.bashrc
vim /etc/bashrc
al final del fichero añadimos:
export PROMPT_COMMAND='RETRN_VAL=$?;logger -p local6.debug "$(whoami) ${HOSTNAME}:${PWD} [$$]: $(history 1 | sed "s/^[ ]*[0-9]\+[ ]*//" ) [$RETRN_VAL]"'
creamos fichero log y cambiamos propietario y permisos:
touch /var/log/cmdhistory.log
chown syslog:adm /var/log/cmdhistory.log
chmod 640 /var/log/cmdhistory.log
Logging de sesiones SFTP
creamos fichero vim /usr/local/bin sftp-wrapper con este contenido:
#!/bin/bash
# sftpd wrapper script pre/post sesiones
#
# acciones pre sesion y logging
SOURCE_IP=${SSH_CLIENT%% *}
MSG_SESSION_START="user $LOGNAME session start from $SOURCE_IP"
logger -p local5.notice -t sftpd-wrapper -i "$MSG_SESSION_START"
# comienzo actual sesion SFTP
/usr/lib/openssh/sftp-server -f LOCAL5 -l VERBOSE
# añadimos acciones post sesion aqui
MSG_SESSION_STOP="user $LOGNAME session ended from $SOURCE_IP"
logger -p local5.notice -t sftpd-wrapper -i "$MSG_SESSION_STOP"
Cambiamos los permisos al fichero:
chmod +x /usr/local/bin/sftp-wrapper
Modificamos el fichero /etc/ssh/sshd_config:
# override default of no subsystems
#Subsystem sftp /usr/lib/openssh/sftp-server
Subsystem sftp /usr/local/bin/sftp-wrapper
Creamos el fichero /var/log/sftp.log y modificamos permisos y propietario:
touch /var/log/sftp.log
chmod 640 /var/log/sftp.log
chown syslog:adm /var/log/sftp.log
Editamos el fichero
vim /etc/rsyslog.conf
y añadimos al final:
##MONITOR CMD y SFTP
local6.* /var/log/cmdhistory.log
local5.* /var/log/sftp.log
Se incluyen ambos ficheros en el logrotate de la máquina y para ello, creamos fichero /etc/logrotate.d/sftp_cmd
vim /etc/logrotate.d/sftp_cmd
y añadimos el contenido:
/var/log/sftp.log
/var/log/cmdhistory.log {
rotate 52
weekly
missingok
notifempty
compress
delaycompress
create 640 syslog adm
sharedscripts
postrotate
invoke-rc.d rsyslog rotate >/dev/null 2>&1 || true
endscript }
Reiniciamos servicios:
systemctl restart sshd
systemctl restart rsyslog

31
Linux/logrotate en linux.txt Normal file
View File

@ -0,0 +1,31 @@
Un muy breve resumen del funcionamiento de logrotate para que los archivos de LOG de nuestras aplicaciones “roten” cuando consigan un tamaño concreto y así sea más legible para el administrador.
A priori, saber que el logrotate es un demonio que se ejecuta de forma autónoma, pero que si queremos comprobar su funcionamiento, sólo debemos lanzar la siguiente instrucción:
logrotate -vf /etc/logrotate.conf
Como podemos ver, logrotate se encuentra bajo la carpeta /etc y también debemos saber que es en ese fichero donde se establece la configuración base para cualquier aplicativo que deseemos rotar. Si queremos fijar una configuración concreta para un aplicativo concreto, debemos ir a la carpeta /etc/logrotate.d y crear un archivo nuevo con la configuración específica.
Un ejemplo de configuración específica para un fichero de log que tenemos en un servidor (/etc/logrotate.d/testlink)
/srv/www/verificacion/testlink/logs/userlog0.log {
copytruncate
daily
rotate 20
compress
missingok
size 10M
}
Ahí estamos diciendo básicamente que:
Daily: realice la comprobación cada día
Compress: Genere un fichero gzip del log rotado
Size: Que genere el archivo gzip cuando el log userlog0.log ocupe 10 megas
Rotate: el nº veces que rotará. Cuando complete ese nº de veces, machará el primero y volverá a empezar.
Missingok: si el fichero de log no existe, no devuelve error.
Copytruncate: creará una copia del fichero original antes de hacer el rotado, de esa forma evitaremos que el log principal no se quede corrompido y nuestro aplicativo siga funcionando con normalidad. Así siempre generará al menos un log de cero bytes y siempre existirá.
Si queremos comprobar únicamente la configuración establecida para este log, debemos ejecutar:
logrotate -vf /etc/logrotate.d/testlink

183
Linux/logrotate.txt Normal file
View File

@ -0,0 +1,183 @@
En sistemas con systemd hay 2 nuevos servicios :
/lib/systemd/system/logrotate.service
/lib/systemd/system/logrotate.timer
logrotate.service es el encargado de lanzar el servicio de logrotate ( /usr/sbin/logrotate /etc/logrotate.conf )
logrotate.timer se encarga de configurar el momento exacto que debe lanzarse el servicio LOGROTATE
--- POSIBLES PROBLEMAS:
Si cuando se lanza el proceso LOGROTATE en el archivo de log ( /var/log/syslog ) indica que la ruta /usr/share/ngix/xxxxxxxx es un sistema de solo lectura y no puede escribir en la ruta solicitada en el archivo /etc/logrotate.d/* hay que editar el archivo /lib/systemd/system/logrotate.service y añadir las siguiente opción ( ReadWritePaths=/usr/share/nginx/XXXXXXXX ) para impedir que cuando lance el proceso logrotate monte la ruta /usr/share/nginx/xxxxxxx en modo lectura
Tras añadir dicha linea en la que podrían haber varios paths separados por espacio (tantos como configuraciones especificas en logrotate.d podamos tener) hay que ejecutar los siguientes comandos:
systemctl daemon-reload
systemctl restart logrotate.timer
Otro problema que puede surgir es que tengamos varios paths definidos en 'ReadWritePaths' y en un momento quitemos una de las configuraciones de logrotate.d/ y se nos olvide quitarla de ReadWritePaths en logrotate.service, en ese caso no arrancará servicio ya que no puede acceder a dicha ruta, solo habrá que eliminarla del path y ejecutar de nuevo los dos comandos indicados arriba.
--- PEQUEÑA GUIA DE LOGROTATE:
Logrotate viene instalado por defecto en la mayoría de las distribuciones de Linux pero su configuración predeterminada puede variar según la distribución que estés utilizando. Sin embargo, la mayoría de las especificaciones mencionadas en este artículo también aplican para otras distribuciones siempre y cuando la versión de Logrotate sea la misma que la mencionada posteriormente.
Verificar versión de Logrotate
Si te encuentras trabajando con un servidor diferente a Ubuntu, primero deberás verificar que Logrotate esté instalado en tu sistema ejecutando el siguiente comando:
logrotate --version
Esto deberá retornar un mensaje como el siguiente:
# Output
logrotate 3.8.7
Si Logrotate no está instalado recibirás un error por lo que deberás instalarlo con tu administrador de paquetes antes de continuar con este tutorial.
Si Logrotate está instalado pero la versión es significativamente diferente a la mostrada, puede que experimentes algunos problemas con las configuraciones que veremos en este tutorial. Puede revisar la documentación de Logrotate de tu versión instalada utilizando el siguiente comando:
man logrotate
A continuación veremos la estructura de la configuración predeterminada de Logrotate en Ubuntu 16.04.
Explorar la configuración de Logrotate
La información de la configuración de Logrotate en Ubuntu puede encontrarse en dos lugares diferentes:
/etc/logrotate.conf: Este archivo contiene algunas configuraciones predeterminadas y configura la rotación para algunos logs que no son propiedad de ningún paquete del sistema. Ademas utiliza una sentencia include para obtener la configuración de cualquier archivo que se encuentre en el directorio /etc/logrotate.d.
/etc/logrotate.d/: Aquí se van a colocar las configuraciones de Logrotate para cualquier paquete que instales en tu servidor que requiera de ayuda para rotar sus logs. En una instalación estándar deberías tener estos archivos aquí para sistemas básicos como apt, dpkg, rsyslog y más.
Veamos el contenido del archivo de configuración logrotate.conf con el siguiente comando:
cat /etc/logrotate.conf
Este comando debería retornar lo siguiente:
# Output
weekly
su root syslog
rotate 4
create
include /etc/logrotate.d
/var/log/wtmp {
missingok
monthly
create 0664 root utmp
rotate 1
}
/var/log/btmp {
missingok
monthly
create 0660 root utmp
rotate 1
}
Por defecto, logrotate.conf va a configurar la rotación de logs de manera semanal (weekly), con archivos de logs que sean propiedad del usuario root y del grupo syslog (su root syslog), manteniendo 4 archivos de logs (rotate 4) y creando un nuevo archivo de log después de que el actual sea rotado (create), luego tomará todos los archivos de /etc/logrotate.d/ y por último va a crear la rotación de logs para 2 archivos más /var/log/wtmp y /var/log/btmp.
Veamos los archivos de configuración de Logrotate para los paquetes en /etc/logrotate.d. En este caso, vamos a mostrar en pantalla el archivo de configuración para el paquete de la utilería apt:
cat /etc/logrotate.d/apt
Este comando debería retornar lo siguiente:
# Output
/var/log/apt/term.log {
rotate 12
monthly
compress
missingok
notifempty
}
/var/log/apt/history.log {
rotate 12
monthly
compress
missingok
notifempty
}
Este archivo contiene bloques de configuración para dos archivos de logs diferentes, en el directorio /var/log/apt/: term.log y history.log. Ambos tienen las mismas opciones. Cualquier opción no indicada en este archivo va a heredar los valores predeterminados en /etc/logrotate.conf. Las opciones indicadas para los logs de apt son las siguientes:
rotate 12: mantiene 12 archivos de logs de antigüedad.
monthly: rotar una vez al mes.
compress: comprimir los archivos que se hayan rotado. Esto utiliza gzip por defecto y los archivos resultantes tendrán la terminación .gz. El comando de compresión puede ser modificado utilizando la opción compresscmd.
missingok: no mostrar mensajes de error si el log en cuestión no existe.
notifempty: no hacer la rotación de logs si el archivo está vacío.
Existen muchas más opciones de configuración disponibles, las cuales podrás visualizar revisando la documentación de Logrotate con el comando man logrotate.
Ahora vamos a configurar la rotación para una aplicación.
Crear un archivo de configuración
Para administrar archivos de logs para las aplicaciones diferentes a los paquetes preinstalados y preconfigurados tenemos dos opciones:
Crear un nuevo archivo de configuración de Logrotate y colocarlo en /etc/logrotate.d/. Esto se ejecutará diariamente como el usuario root junto con todas las demás tareas de Logrotate estándar.
Crear un nuevo archivo de configuración y ejecutarlo fuera de la configuración de Logrotate predeterminada. Esto es solamente necesario si se desea ejecutar Logrotate con un usuario diferente a root, o si deseas hacer la rotación de logs de manera más frecuente, por ejemplo, rotar los logs cada hora.
Veamos un ejemplo de ambas opciones:
Agregar una configuración en /etc/logrotate.d/
Para este ejemplo vamos a crear la configuración necesaria para rotar los logs de un servidor web ficticio que pone los archivos access.log y error.log en el directorio /var/log/example-app/. Este servidor es ejecutado como el usuario y grupo www-data.
A continuación podremos ver un ejemplo de la configuración para estos logs:
/var/log/example-app/*.log {
daily
missingok
rotate 14
compress
notifempty
create 0640 www-data www-data
sharedscripts
postrotate
systemctl reload example-app
endscript
}
Algunas de las directivas nuevas hasta este momento son las siguientes:
create 0640 www-data www-data: esta directiva va a crear los archivos de logs después de la rotación con los permisos especificados (0640), propietario (www-data) y grupo (www-data).
sharedscripts: con esta directiva podemos indicar que los scripts añadidos se ejecutarán solamente una vez por ejecución y no una vez por archivo. Ya que esta aplicación de ejemplo tiene dos logs, los scripts que vamos a agregar a continuación se ejecutarán solamente una vez por rotación, y no una vez para cada archivo de log. En caso de no indicar esta directiva, los scripts indicados en postrotate se ejecutarían dos veces para este ejemplo.
postrotate y endscript: este es un bloque que contiene todos los scripts que deseamos ejecutar una vez que se finalice la rotación de los logs. En este ejemplo vamos a reiniciar la configuración de example-app después de que se hayan rotado los logs.
Una vez que hayamos finalizado de editar el archivo de configuración tendremos que guardarlo en /etc/logrotate.d. Es posible probar la configuración con el siguiente comando:
sudo logrotate /etc/logrotate.conf --debug
Esto hará una llamada a logrotate, apuntando a la configuración estándar y activará el modo debug. También se mostrará información en pantalla correspondiente a los archivos que Logrotate estará manejando y qué habría hecho con ellos.
Recuerda que Logrotate se ejecuta una vez al día para los archivos que se encuentran en /etc/logrotate.d/.
Crear una configuración independiente de Logrotate
Como lo mencionamos anteriormente, esta es la configuración que debemos hacer para aplicaciones que no se están ejecutando como root, o que requieren de rotaciones más frecuentes, lo cual lo hace perfecto para poder rotar archivos de logs para aplicaciones de Laravel.
En este ejemplo nuestra aplicación se está ejecutando con el usuario styde y está generando logs en el directorio /home/styde/laravel/storage/logs/. Vamos a crear una configuración para poder rotar los logs de nuestra aplicación:
nano /home/styde/logrotate.conf
Dentro de este archivo vamos a poner lo siguiente:
/home/styde/laravel/storage/logs/* {
hourly
missingok
rotate 24
compress
create
}
Con este ejemplo estaremos rotando los logs cada hora y estaremos almacenando 24 archivos de logs, los cuales estarán comprimidos y por último se creará un nuevo archivo de log para remplazar el que ha sido rotado. Después debemos guardar los cambios y probar que esté funcionando.
Dado que nuestra aplicación está ejecutándose con el usuario styde no necesitamos de sudo, pero sí necesitaremos especificar un archivo de estado (state). Este archivo registra todo lo que Logrotate hizo durante la última vez que se ejecutó así que debemos indicarlo al momento de ejecutar la rotación.
Vamos a ejecutar Logrotate para que se cree este archivo de estado por nosotros, siendo explícitos sobre en donde está nuestro archivo de configuración:
logrotate /home/styde/logrotate.conf --state /home/styde/logrotate-state --verbose
Y vamos a obtener un mensaje como el siguiente:
# Output
reading config file /home/styde/logrotate.conf
Handling 1 logs
rotating pattern: /home/styde/laravel/storage/logs/*.log hourly (24 rotations)
empty log files are rotated, old logs are removed
considering log /home/styde/laravel/storage/logs/access.log
log does not need rotating
La opción --verbose va a mostrar en pantalla información detallada de lo que está haciendo Logrotate. En este caso parece no haber hecho nada ya que es la primera vez que Logrotate puede ver nuestro archivo de log.
Si revisamos el archivo de estado podremos ver algo de información al respecto:
cat /home/styde/logrotate-state
Por último debemos crear una tarea para que esto se ejecute cada hora y podemos hacerlo con el comando crontab -e. Este comando nos abrirá la configuración de tareas programadas para nuestro usuario styde, así que debemos poner algo como lo siguiente:
15 * * * * /usr/sbin/logrotate /home/styde/logrotate.conf --state /home/styde/logrotate-state
Con esto lograremos que nuestros logs se ejecuten cada hora en el minuto 15. Indicamos la ruta completa de Logrotate /usr/sbin/logrotate ya que hacer esto es una buena práctica en las tareas programadas.

84
Linux/lvm.txt Normal file
View File

@ -0,0 +1,84 @@
Crear grupo y volumen (particion /dev/vdb1)
# Creamos Grupo
pvcreate /dev/vdb1
vgcreate vg_datos /dev/vdb1
vgdisplay
# Creamos disco lógico
lvcreate -n lv_datos --size 120GB vg_datos # damos un espacio específico
lvcreate -n lv_datos -l 100%FREE vg_datos # asignamos todo el espacio libre
lvdisplay
# Creamos el nuevo sistema de ficheros
mkfs.ext4 /dev/vg_datos/lv_datos
# Montamos el sistema de ficheros
mount /dev/vg_datos/lv_datos /datos
nano /etc/fstab
/dev/mapper/vg_datos-lv_datos /datos ext4 errors=remount-ro 0 1
Expandir VG añadiendo partición
# añadir partición o disco físico al sistema y comprobar que se ve
fdisk -l
# crear volumen fisico en esa partición
pvcreate /dev/sdX
# identifica el grupo
vgs
# expande el volumen usando el nuevo volumen físico creado
vgextend VG_DESEADO /dev/sdX
# comprueba que todo esté correcto
vgs
vgdisplay
Expandir VG aumentando tamaño partición existente
# aumentar partición con parted
parted
p
resizepart
quit
# aumentar el volumen de grupo
pvresize /dev/[PARTICION]
# comprobar que el VG ha aumentado de tamaño
vgs
Expandir LVM
# tres opciones:
# expandir el volumen lógico a todo el espacio libre
lvextend -l +100%FREE /dev/mapper/ubuntu--vg-home--lv
# expandir volumen lógico en 10GB
lvextend -L10G /dev/mapper/ubuntu--vg-home--lv
# añadir 1GB al volumen
lvextend -L+1G /dev/myvg/ubuntu--vg-home--lv
# verificar el tamaño en los volúmenes lógicos
lvdisplay
# chequear sistema de ficheros
e2fsck -fy /dev/mapper/ubuntu--vg-home--lv
# hacer crecer el sistema de archivos para llenar el volumen
resize2fs /dev/mapper/ubuntu--vg-home--lv
Reducir LVM (si es / arrancar desde livecd)
# activar volúmenes LVM
vgchange -a y
# verificar grupo de volúmenes
vgs
# chequear sistema de ficheros
e2fsck -fy /dev/mapper/ubuntu--vg-ubuntu--lv
# verificar volúmenes lógicos
lvdisplay
# reducir el tamaño del sistema de ficheros por debajo del tamaño del volumen lógico
resize2fs /dev/mapper/ubuntu--vg-ubuntu--lv 29G
# reducir el volumen lógico (debe ser algo superior al tamaño del sistema de ficheros)
lvreduce -L 30G /dev/mapper/ubuntu--vg-ubuntu--lv
# hacer crecer el sistema de archivos para llenar el volumen
resize2fs /dev/mapper/ubuntu--vg-ubuntu--lv
# verificar tamaños
lvdisplay
# verificar si el tamaño libre se muestra en el grupo de volúmenes
vgdisplay
# renombrar un LVM
lvrename VG LV_antiguo LV_nuevo

8
Linux/make a cheat system for linux console.txt Normal file
View File

@ -0,0 +1,8 @@
sudo apt-get install python-pip
sudo apt-get install git
sudo pip install docopt pygments
git clone https://github.com/chrisallenlane/cheat.git
cd cheat
sudo python setup.py install
wget https://github.com/chrisallenlane/cheat/raw/master/cheat/autocompletion/cheat.bash
sudo cp cheat.bash /etc/bash_completion.d/

73
Linux/matar procesos que bloquean archivos usando fuser.txt Normal file
View File

@ -0,0 +1,73 @@
Fuser es un comando muy poco conocido pero muy potente en Linux, identifica qué procesos están utilizando un fichero o carpeta determinada o un socket. De la misma forma podemos usarlo para matar esos mismos procesos.
--- La forma más simple de utilizarlo sería así:
m3t4g4m3@nexolinux ~ $ fuser .
/home/m3t4g4m3: 5663c
Cuyo PID nos muestra el proceso que muestra que mi propio usuario está usando ese directorio al encontrarme en él:
m3t4g4m3@nexolinux ~ $ ps -ef | grep 5663
m3t4g4m3 5663 5655 0 13:30 pts/2 00:00:00 -su
La «c» del proceso que muestra también nos aporta información, en este caso es «directorio actual» (Current directory)
También podemos ver esta nomenclatura:
c Directorio actual (current directory)
e Ejecutable activo (executable being run)
f Fichero abierto, omitido en el modo por defecto (open file)
F Fichero abierto para escritura, omitido en el modo por defecto (open file for writing)
r Directorio raíz (root directory)
m Fichero mapeado o biblioteca compartida (maped file or shared library)
--- Si ejecutamos fuser sobre un ejecutable como el servidor web nginx tenemos esto:
nexolinux sbin # fuser -v nginx
USER PID ACCESS COMMAND
/usr/sbin/nginx: root 6444 ...e. nginx
www-data 6445 ...e. nginx
www-data 6446 ...e. nginx
www-data 6447 ...e. nginx
www-data 6448 ...e. nginx
--- Si lo ejecutamos sobre un socket
nos dará esta valiosa información. Como por ejemplo en el puerto 80 que arranca el nginx
nexolinux sbin # fuser -v -n tcp 80
USER PID ACCESS COMMAND
80/tcp: root 6444 F.... nginx
www-data 6445 F.... nginx
www-data 6446 F.... nginx
www-data 6447 F.... nginx
www-data 6448 F.... nginx
--- Matar procesos que de un software determinado:
nexolinux sbin # ps -ef | grep nginx | grep -v grep
root 7112 1 0 14:21 ? 00:00:00 nginx: master process ./nginx
www-data 7113 7112 0 14:21 ? 00:00:00 nginx: worker process
www-data 7114 7112 0 14:21 ? 00:00:00 nginx: worker process
www-data 7115 7112 0 14:21 ? 00:00:00 nginx: worker process
www-data 7116 7112 0 14:21 ? 00:00:00 nginx: worker process
nexolinux sbin # fuser -v -k nginx
USER PID ACCESS COMMAND
/usr/sbin/nginx: root 7112 ...e. nginx
www-data 7113 ...e. nginx
www-data 7114 ...e. nginx
www-data 7115 ...e. nginx
www-data 7116 ...e. nginx
nexolinux sbin # ps -ef | grep nginx | grep -v grep
nexolinux sbin #
5- Matar procesos selectivos de forma interactiva.
Pero imaginemos por un momento que una carpeta o binario donde vamos a ejecutarlo pueda ser usado por muchas aplicaciones o directamente lo desconozcamos, como medida de cautela, usamos el argumento «-i» para que nos pregunte si queremos o no matar un proceso determinado:
nexolinux sbin # fuser -v -i -k nginx
USER PID ACCESS COMMAND
/usr/sbin/nginx: root 7291 ...e. nginx
www-data 7292 ...e. nginx
www-data 7293 ...e. nginx
www-data 7294 ...e. nginx
www-data 7295 ...e. nginx
Kill process 7291 ? (y/N) y
Kill process 7292 ? (y/N) y
Kill process 7293 ? (y/N) y
Kill process 7294 ? (y/N) y
Kill process 7295 ? (y/N)

195
Linux/montar servidor de log gratuito con Rsyslog, MySQL y LogAnalyzer.txt Normal file
View File

@ -0,0 +1,195 @@
Montar servidor de log gratuito con Rsyslog, MySQL y LogAnalyzer
Fecha Miércoles, 20 marzo a las 23:43:30
Tema Seguridad Informática
Cómo montar un servidor de log gratuito usando Rsyslog en Linux Ubuntu Server, guardando los datos en MySQL. Mostramos cómo instalar LogAnalyzer para generar informes y realizar consultas sobre los log.
● Servidor de log syslog.
● Requisitos para montar servidor de log gratuito con Rsyslog.
● Instalar Rsyslog en GNU Linux Ubuntu Server 12.
● Instalar LogAnalyzer para consulta vía web de los log de Rsyslog.
● Anexo.
● Artículos relacionados.
● Créditos.
Servidor de log syslog
Syslog es un estándar desarrollado para el envío de mensajes de registro a una IP en una red LAN. Syslog hace referencia tanto al protocolo de red como a la aplicación o biblioteca que envía los mensajes de registro.
Los equipos y servicios con soporte para envío de log a este sistema pueden enviar cualquier tipo de mensaje, normalmente suelen enviar información sobre la seguridad del sistema, errores, avisos, etc. aunque pueden contener cualquier información. Junto con cada mensaje se incluye la fecha y hora del envío, el equipo que envía, la prioridad y otros datos adicionales.
El protocolo syslog consiste en un equipo servidor ejecutando el servidor de syslog, conocido como syslogd (demonio de syslog) y clientes que envían un pequeño mensaje de texto (de menos de 1024 bytes) a este servidor.
Los mensajes de syslog se suelen enviar vía UDP, por el puerto 514, en formato de texto plano. Algunas implementaciones del servidor, como syslog-ng, permiten usar TCP en vez de UDP, y también ofrecen Stunnel para que los datos viajen cifrados mediante SSL/TLS.
Aunque syslog tiene algunos problemas de seguridad, su sencillez ha hecho que muchos dispositivos lo implementen, tanto para enviar como para recibir. Eso hace posible integrar mensajes de varios tipos de sistemas en un solo repositorio central.
El mensaje enviado se compone de tres campos, entre todos no han de sumar más de 1024 bytes, pero no hay longitud mínima:
● Prioridad: número de 8 bits que indica tanto el recurso (tipo de aparato que ha generado el mensaje) como la severidad (importancia del mensaje).
● Cabecera: indica tanto el tiempo como el nombre del ordenador que emite el mensaje. Esto se escribe en codificación ASCII (7 bits), por tanto es texto legible. El primer campo, tiempo, se escribe en formato Mmm dd hh:mm:ss, donde Mmm son las iniciales del nombre del mes en inglés, dd, es el día del mes, y el resto es la hora. No se indica el año. Justo después viene el nombre de ordenador (hostname), o la dirección IP si no se conoce el nombre. No puede contener espacios, ya que este campo acaba cuando se encuentra el siguiente espacio.
● Texto: lo que queda de paquete syslog al llenar la prioridad y la cabecera es el propio texto del mensaje. Éste incluirá información sobre el proceso que ha generado el aviso, normalmente al principio (en los primeros 32 caracteres) y acabado por un carácter no alfanumérico (como un espacio, ":" o "["). Después, viene el contenido real del mensaje, sin ningún carácter especial para marcar el final.
Requisitos para montar servidor de log gratuito con Rsyslog
Para montar un servidor de log con el estándar syslog usando el software gratuito Rsyslog necesitaremos un equipo (físico o virtual) con el sistema operativo GNU Linux, utilizaremos la distribución GNU Linux Ubuntu Server 12.01. Además, necesitaremos un servidor web y una base de datos. En este tutorial explicamos cómo guardar los log de Rsyslog en el motor de base de datos MySQL Server y cómo consultarlos mediante LogAnalyzer vía web por lo que necesitaremos un servidor web con Apache y PHP.
En el siguiente tutorial explicamos cómo instalar el sistema operativo GNU Linux Ubuntu Server 12.01 en un equipo nuevo (virtual o físico) con el paquete LAMP que instala automáticamente Apache + PHP + MySQL:
● Servidor web con Ubuntu Server 12 y LAMP Server Apache PHP MySQL.
Si ya tenemos el servidor con Linux en los siguientes tutoriales explicamos cómo instalar MySQL y Apache en Linux:
● Cómo instalar MySQL Server en Linux y permitir conexiones remotas.
● Instalar y configurar MySQL Server 5 en Linux Suse 10.
● Instalar Linux Ubuntu Server 11 x64, Apache, MySQL, PostgreSQL, Tomcat, Webmin.
● Montar servidor web con Apache en Linux Debian 5 con MySQL y PHP.
Instalar Rsyslog en GNU Linux Ubuntu Server 12
A continuación vamos a explicar cómo instalar el servidor de log syslog gratuito Rsyslog en un equipo con Ubuntu Server 12, en primer lugar instalaremos la clave necesaria con el siguiente comando linux:
sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com AEF0CF8E
A continuación editaremos el fichero sources.list y añadiremos una línea nueva, para ello ejecutaremos el comando linux:
sudo nano /etc/apt/sources.list
Añadiremos las siguientes líneas al final del fichero:
deb http://ubuntu.adiscon.com/v7-devel precise/
deb-src http://ubuntu.adiscon.com/v7-devel precise/
Guardaremos los cambios pulsando Control + O y cerraremos la edición pulsando Control + X:
Actualizaremos el sistema y la lista de paquetes con el comando linux:
sudo apt-get update && sudo apt-get upgrade
Tras concluir la actualización instalaremos Rsyslog con el comando linux:
sudo apt-get install rsyslog
No solicitará confirmación para instalar, pulsaremos la tecla "s" e INTRO:
Ahora instalaremos el soporte de Rsyslog para bases de datos MySQL con el comando linux:
install rsyslog-mysql
El asistente para instalar el paquete nos preguntará si queremos configurar la base de datos para rsyslog-mysql con dbconfig-common, seleccionaremos "Sí" y pulsaremos INTRO:
Con el texto: Es necesario tener una base de datos instalada y configurada para rsyslog-mysql antes de poder utilizarlo. Puede gestionar esto opcionalmente a través de "dbconfig-common". Si ud. es un administrador de bases de datos avanzado o si la base de datos ya está instalada y configurada quizás quiera realizar esta configuración manualmente, y debería rechazar esta opción. Probablemente podrá encontrar los detalles de las operaciones que debe realizar en "/usr/share/doc/rsyslog-mysql".
Introduciremos la contraseña del superusuario root de MySQL Server, el paquete rsyslog-mysql deberá acceder a MySQL y crear un usuario, un catálogo y las tablas correspondientes:
Introduciremos ahora la contraseña para que rsyslog-mysql acceda al servidor de MySQL:
Confirmamos la contraseña:
El asistente creará los ficheros de configuración necesarios, el usuario, catálogo y tablas en MySQL:
Accediendo con MySQL Administrator, MySQL MySQL Workbench o cualquier software para acceder a MySQL como AjpdSoft Administración Bases de Datos podremos consultar el esquema creado por rsyslog-mysql "Syslog", las tablas "SystemEvents" y "SystemEventsProperties":
Y el usuario "rsyslog":
El systema Rsyslog ya habrá empezado a guardar los eventos de log en MySQL, podremos consultarlos con MySQL Administrator pulsando sobre la tabla "SystemEvents" con el botón derecho del ratón y seleccionando "Edit Table Data":
Se abrirá MySQL Query Browser y mostrará los registros de log que Rsyslog ya ha guardado en la tabla:
Las consultas SQL de creación de las dos tablas del catálogo Syslog de MySQL:
CREATE TABLE `SystemEvents` (
`ID` int(10) unsigned NOT NULL AUTO_INCREMENT,
`CustomerID` bigint(20) DEFAULT NULL,
`ReceivedAt` datetime DEFAULT NULL,
`DeviceReportedTime` datetime DEFAULT NULL,
`Facility` smallint(6) DEFAULT NULL,
`Priority` smallint(6) DEFAULT NULL,
`FromHost` varchar(60) DEFAULT NULL,
`Message` text,
`NTSeverity` int(11) DEFAULT NULL,
`Importance` int(11) DEFAULT NULL,
`EventSource` varchar(60) DEFAULT NULL,
`EventUser` varchar(60) DEFAULT NULL,
`EventCategory` int(11) DEFAULT NULL,
`EventID` int(11) DEFAULT NULL,
`EventBinaryData` text,
`MaxAvailable` int(11) DEFAULT NULL,
`CurrUsage` int(11) DEFAULT NULL,
`MinUsage` int(11) DEFAULT NULL,
`MaxUsage` int(11) DEFAULT NULL,
`InfoUnitID` int(11) DEFAULT NULL,
`SysLogTag` varchar(60) DEFAULT NULL,
`EventLogType` varchar(60) DEFAULT NULL,
`GenericFileName` varchar(60) DEFAULT NULL,
`SystemID` int(11) DEFAULT NULL,
PRIMARY KEY (`ID`) );
CREATE TABLE `SystemEventsProperties` (
`ID` int(10) unsigned NOT NULL AUTO_INCREMENT,
`SystemEventID` int(11) DEFAULT NULL,
`ParamName` varchar(255) DEFAULT NULL,
`ParamValue` text,
PRIMARY KEY (`ID`) );
De esta sencilla forma ya tendremos montado un servidor de log syslog con Rsyslog sobre Linux de forma gratuita y guardando los log en MySQL, por lo tanto podremos consultarlos desde cualquier aplicación que permita acceso a MySQL o bien usar algún software gratuito como LogAnalyzer.
Instalar LogAnalyzer para consulta vía web de los log de Rsyslog
Explicaremos ahora cómo instalar el sistema LogAnalyzer en nuestro servidor de log syslog que nos permitirá consultar vía web con un entorno amigable los eventos que Rsyslog registre en MySQL. Para ello en primer lugar crearemos una carpeta para la descarga temporal del paquete comprimido con:
sudo mkdir /tmp/loganalyzer
Buscaremos en la web oficial de LogAnalyzer la última versión y anotaremos la URL de la descarga, para descargar el fichero comprimido desde la consola de Linux Ubuntu Server accederemos a la carpeta creada para la descarga con:
cd /tmp/loganalyzer
Y descargaremos el fichero con:
wget http://download.adiscon.com/loganalyzer/loganalyzer-3.6.3.tar.gz
( cambiando la URL por la que corresponda a la versión actual)
Descomprimiremos el fichero descargado con el comando linux:
tar -xvf loganalyzer-3.6.3.tar.gz
Accederemos a la carpeta que se habrá creado al descomprimir con:
cd /tmp/loganalyzer/loganalyzer-3.6.3
Crearemos una subcarpeta dentro de la carpeta www de Apache de nuestro servidor web con:
sudo mkdir /var/www/loganalyzer
Ahora copiaremos el contenido de la carpeta "src" a la carpeta creada con:
sudo cp -R /tmp/loganalyzer/loganalyzer-3.6.3/src/* /var/www/loganalyzer
Repetiremos la operación para la carpeta "contrib":
sudo cp -R /tmp/loganalyzer/loganalyzer-3.6.3/contrib/* /var/www/loganalyzer
Estableceremos permisos de escritura para los ficheros configure.sh y secure.sh:
cd /var/www/loganalyzer
sudo chmod +x configure.sh secure.sh
Iniciaremos LogAnalyzer vía web desde cualquier PC de la red abriendo un navegador e introduciendo la URL:
http://192.168.31.156/loganalyzer
(cambiaremos "192.168.31.156 por la IP de nuestro servidor syslog)
Se iniciará LogAnalyzer, en el primer inicio dará un error al detectar que aún no ha sido configurado, pulsaremos en "here" para instalar Adisco LogAnalyzer:
Con el texto: Critical Error occured. Error, main configuration file is missing! Click here to Install Adiscon LogAnalyzer!
Se iniciará el asistente para configurar e instalar definitivamente LogAnalyzer, pulsaremos "Next":
El fichero config.php debe ser escribible, en el siguiente paso el asistente de instalación de LogAnalyzer lo comprobará, de no serlo deberemos establecerle los permisos apropiados con el comando linux chmod:
Introduciremos los datos de configuración, los importantes son:
● Enable User database: marcaremos "Yes".
● Database Host: IP o nombre DNS (hostname) del equipo servidor de syslog con MySQL.
● Database Port: puerto de la base de datos MySQL, por defecto 3306.
● Database Name: nombre del catálogo de MySQL que el asistente creará para LogAnalyzer, por ejemplo "loganalyzer".
● Table prefix: prefijo que se añadirá al nombre de las tablas, esto es últil si queremos usar un catálogo ya existente, así separaremos por nombre las tablas de otras existentes.
● Database User: usuario que se creará en la base de datos MySQL para uso de LogAnalyzer.
● Database Password: contraseña para el usuario anterior.
● Require user to be logged in: marcaremos "Yes".
● Authentication method: seleccionaremos "Internal authentication".
El resto de parámetros son de visualización de los log, podremos modificarlos en cualquier momento:
A continuación el asistente para instalar LogAnalyzer nos indicará que se van a crear las tablas en el catálogo de MySQL elegido, pulsaremos "Next":
Si el proceso es correcto nos indicará las tablas creadas, pulsaremos "Next":
Introduciremos ahora los datos del usuario que se creará para acceder a LogAnalyzer:
Introduciremos ahora los datos de la fuente, LogAnalyzer permite analizar y consultar varios servidores de log con syslog, por lo que ahora crearemos el acceso a nuestro servidor de syslog con Rsyslog, para ello introduciremos los siguientes datos:
● Name of the Source: nombre del origen, por ejemplo "Log AjpdSoft", este nombre se usará para diferenciar varios servidores de log con syslog.
● Source Type: seleccionaremos "MYSQL Native".
● Select View: seleccionaremos "Syslog Fields".
● Table type: seleccionaremos "MonitorWare".
● Database Host: introduciremos la IP o nombre DNS de nuestro servidor con Rsyslog y MySQL.
● Database Name: introduciremos el nombre del catálogo que contiene las tablas de Rsyslog, por defecto "Syslog".
● Database Tablename: nombre de la tabla con los eventos de Rsyslog en MySQL, por defecto "SystemEvents".
● Database User: nombre de usuario de MySQL con permisos de acceso a las tablas de Rsyslog, por defecto "rsyslog".
● Database Password: contraseña del usuario anterior.
● Enable Row Counting: si vamos a tener un servidor de log con no demasiados eventos podremos marcar "Yes", si vamos a tener cientos de miles de eventos no es recomendable activar esta opción pues puede ralentizar el acceso.
De esta forma LogAnalyzer permite tener sus propias tablas alojadas en un servidor de MySQL diferente al de Rsyslog (o puede ser el mismo como en nuestro caso):
El proceso de instalación de LogAnalyzer habrá concluido:
Introduciendo la URL en un navegador:
http://192.168.31.156/loganalyzer
(cambiaremos "192.168.31.156 por la IP de nuestro servidor syslog)
Nos solicitará usuario y contraseña, introducimos el elegido en el proceso de instalación y pulsamos en "Login":
Y ya tendremos acceso a la consulta avanzada de los log generamos por nuestro servidor de syslog con Rsyslog desde LogAnalyzer:
Anexo
● Si se produce el error: ERROR: At least one file or directory (or more) is not writeable, please check the file permissions (chmod 666)! al intentar instalar LogAnalyzer se deben revisar los permisos de la carpeta /var/www/loganalyzer, en concreto los de los ficheros configure.sh, secure.sh y config.php.
● Si se poduce algún error de falta de permisos para algún usuario de MySQL tal vez sea necesario asignarle permisos, una forma para hacerlo es desde la línea de comandos de Linux, con los comandos:
mysql -u root -p
grant all privileges on Syslog.* to 'rsyslog'@'%' with grant option;

267
Linux/montar un Servidor syslog en Linux con rsyslog y LogAnalyzer.txt Normal file
View File

@ -0,0 +1,267 @@
Montar un Servidor syslog en Linux con rsyslog y LogAnalyzer
Buenas, hoy hablaremos de los conceptos básicos acerca de que es un servidor Syslog, su utilidad, y la forma de instalarlo. En este caso hablaremos de la forma de instalarlo en una instalación debian 7, aunque es perfectamente aplicable a debian 8 y cualquier otra base Debian.
Concepto de Syslog y su utilidad
Syslog es un estándar desarrollado para el envío de mensajes de registro a una IP en una red LAN. Syslog hace referencia tanto al protocolo de red como a la aplicación o biblioteca que envía los mensajes de registro.
Los equipos y servicios con soporte para envío de log a este sistema pueden enviar cualquier tipo de mensaje, normalmente suelen enviar información sobre la seguridad del sistema, errores, avisos, etc. aunque pueden contener cualquier información. Junto con cada mensaje se incluye la fecha y hora del envío, el equipo que envía, la prioridad y otros datos adicionales.
El protocolo syslog consiste en un equipo servidor ejecutando el servidor de syslog, conocido como syslogd (demonio de syslog) y clientes que envían un pequeño mensaje de texto (de menos de 1024 bytes) a este servidor.
Los mensajes de syslog se suelen enviar vía UDP, por el puerto 514, en formato de texto plano. Algunas implementaciones del servidor, como syslog-ng, permiten usar TCP en vez de UDP, y también ofrecen Stunnel para que los datos viajen cifrados mediante SSL/TLS.
Aunque syslog tiene algunos problemas de seguridad, su sencillez ha hecho que muchos dispositivos lo implementen, tanto para enviar como para recibir. Eso hace posible integrar mensajes de varios tipos de sistemas en un solo repositorio central.
El mensaje enviado se compone de tres campos, entre todos no han de sumar más de 1024 bytes, pero no hay longitud mínima:
Prioridad: número de 8 bits que indica tanto el recurso (tipo de aparato que ha generado el mensaje) como la severidad (importancia del mensaje).
Cabecera: indica tanto el tiempo como el nombre del ordenador que emite el mensaje. Esto se escribe en codificación ASCII (7 bits), por tanto es texto legible. El primer campo, tiempo, se escribe en formato Mmm dd hh:mm:ss, donde Mmm son las iniciales del nombre del mes en inglés, dd, es el día del mes, y el resto es la hora. No se indica el año. Justo después viene el nombre de ordenador (hostname), o la dirección IP si no se conoce el nombre. No puede contener espacios, ya que este campo acaba cuando se encuentra el siguiente espacio.
Texto: lo que queda de paquete syslog al llenar la prioridad y la cabecera es el propio texto del mensaje. Éste incluirá información sobre el proceso que ha generado el aviso, normalmente al principio (en los primeros 32 caracteres) y acabado por un carácter no alfanumérico (como un espacio, ":" o "["). Después, viene el contenido real del mensaje, sin ningún carácter especial para
Requisitos para montar servidor de log gratuito con Rsyslog
Para montar un servidor de log con el estándar syslog usando el software Rsyslog necesitaremos un equipo (físico o virtual) con el sistema operativo GNU Linux. en nuestro caso como ya dijimos utilizaremos la distribución GNU Linux DEBIAN 7. Además, necesitaremos un servidor web y una base de datos, pues se explicará cómo guardar los log de Rsyslog en el motor de base de datos MySQL Server y cómo consultarlos mediante LogAnalyzer vía web por lo que necesitaremos un servidor web con Apache y PHP.
En este sentido, los requisitos mínimos son un equipo con un núcleo, de preferencia 2 y mínimo 512mb, ampliables debido a que si se aumenta el volumen de datos la memoria se puede quedar corta. Por ello hay que tener la salvedad de proveer un entorno en donde se pueda crecer de ser requerido.
Instalar Rsyslog en DEBIAN GNU Linux
A continuación vamos a explicar cómo instalar el servidor de log syslog gratuito Rsyslog en un equipo Debian. Para ello editaremos el fichero sources.list y añadiremos una línea nueva, para ello ejecutaremos los comando linux:
apt-get install gpm ssh vi¬m ntpdate tcpdump iptraf
Tras concluir la actualización instalaremos Rsyslog con el comando linux: No solicitará confirmación para instalar, pulsaremos la tecla "s" e INTRO:
INSTALACIÓN Y CONFIGURACIÓN DE APACHE Y MYSQL:
Para instalar Mysql, Apache 2, PHP5 y algunas librerías necesarias ejecutaremos el siguiente comando:
apt-get install mysql-server apache2 php5 php5-mysql php5-gd
La instalación nos preguntará por los password del root de MySQL, los pondremos y memorizaremos ya que los necesitaremos en la instalación de rsyslog-mysql (descrito mas adelante)
Una vez instalado todo reiniciaremos el servicio Apache2 para que coja la librería gd, que nos creará las imágenes de gráficos estadísticos en LogAnalizer:
sudo /etc/init.d/apache2 restart
Restarting web server: apache2 … waiting .
INSTALACIÓN Y CONFIGURACIÓN DE RSYSLOG:
Para instalar Rsyslog y el módulo para escribir en mysql:
apt-get install rsyslog rsyslog-mysql
Esto instala el soporte de Rsyslog junto al soporte para bases de datos MySQL.
El asistente para instalar el paquete nos preguntará si queremos configurar la base de datos para rsyslog-mysql con dbconfig-common, seleccionaremos "Sí" y pulsaremos INTRO:
Con el texto: Es necesario tener una base de datos instalada y configurada para rsyslog-mysql antes de poder utilizarlo. Puede gestionar esto opcionalmente a través de "dbconfig-common". Si ud. es un administrador de bases de datos avanzado o si la base de datos ya está instalada y configurada quizás quiera realizar esta configuración manualmente, y debería rechazar esta opción. Probablemente podrá encontrar los detalles de las operaciones que debe realizar en "/usr/share/doc/rsyslog-mysql".
Introduciremos la contraseña del superusuario root de MySQL Server, el paquete rsyslog-mysql deberá acceder a MySQL y crear un usuario, un catálogo y las tablas correspondientes:
Introduciremos ahora la contraseña para que rsyslog-mysql acceda al servidor de MySQL:
Confirmamos la contraseña:
El asistente creará los ficheros de configuración necesarios, el usuario, catálogo y tablas en MySQL:
Accediendo con MySQL Administrator, MySQL MySQL Workbench o cualquier software para acceder a MySQL como AjpdSoft Administración Bases de Datos podremos consultar el esquema creado por rsyslog-mysql "Syslog", las tablas "SystemEvents" y "SystemEventsProperties":
Y el usuario "rsyslog":
El systema Rsyslog ya habrá empezado a guardar los eventos de log en MySQL, podremos consultarlos con MySQL Administrator pulsando sobre la tabla "SystemEvents" con el botón derecho del ratón y seleccionando "Edit Table Data":
Se abrirá MySQL Query Browser y mostrará los registros de log que Rsyslog ya ha guardado en la tabla:
Las consultas SQL de creación de las dos tablas del catálogo Syslog de MySQL:
CREATE TABLE `SystemEvents` (
`ID` int(10) unsigned NOT NULL AUTO_INCREMENT,
`CustomerID` bigint(20) DEFAULT NULL,
`DeviceReportedTime` datetime DEFAULT NULL,
`ReceivedAt` datetime DEFAULT NULL,
`Facility` smallint(6) DEFAULT NULL,
`Message` text,
`Priority` smallint(6) DEFAULT NULL,
`FromHost` varchar(60) DEFAULT NULL,
`EventUser` varchar(60) DEFAULT NULL,
`NTSeverity` int(11) DEFAULT NULL,
`Importance` int(11) DEFAULT NULL,
`EventSource` varchar(60) DEFAULT NULL,
`EventCategory` int(11) DEFAULT NULL,
`MinUsage` int(11) DEFAULT NULL,
`EventID` int(11) DEFAULT NULL,
`EventBinaryData` text,
`MaxAvailable` int(11) DEFAULT NULL,
`CurrUsage` int(11) DEFAULT NULL,
`EventLogType` varchar(60) DEFAULT NULL,
`MaxUsage` int(11) DEFAULT NULL,
`InfoUnitID` int(11) DEFAULT NULL,
`SysLogTag` varchar(60) DEFAULT NULL,
`GenericFileName` varchar(60) DEFAULT NULL,
`SystemEventID` int(11) DEFAULT NULL,
`SystemID` int(11) DEFAULT NULL,
PRIMARY KEY (`ID`) );
CREATE TABLE `SystemEventsProperties` (
`ID` int(10) unsigned NOT NULL AUTO_INCREMENT,
`ParamName` varchar(255) DEFAULT NULL,
PRIMARY KEY (`ID`) );
`ParamValue` text,
De esta sencilla forma ya tendremos montado un servidor de syslog con Rsyslog sobre Linux de forma gratuita y guardando los log en MySQL, por lo tanto podremos consultarlos desde cualquier aplicación que permita acceso a MySQL o bien usar algún software gratuito como LogAnalyzer.
Instalar LogAnalyzer para consulta vía web de los log de Rsyslog
Explicaremos ahora cómo instalar el sistema LogAnalyzer en nuestro servidor de log syslog que nos permitirá consultar vía web con un entorno amigable los eventos que Rsyslog registre en MySQL. Para ello en primer lugar crearemos una carpeta para la descarga temporal del paquete comprimido con:
sudo mkdir /tmp/loganalyzer
Buscaremos en la web oficial de LogAnalyzer la última versión y anotaremos la URL de la descarga, para descargar el fichero comprimido desde la consola de Linux Ubuntu Server accederemos a la carpeta creada para la descarga con:
cd /tmp/loganalyzer
Y descargaremos el fichero con:
wget http://download.adiscon.com/loganalyzer/loganalyzer-3.6.3.tar.gz
( cambiando la URL por la que corresponda a la versión actual)
Descomprimiremos el fichero descargado con el comando linux:
tar -xvf loganalyzer-3.6.3.tar.gz
Accederemos a la carpeta que se habrá creado al descomprimir con:
cd /tmp/loganalyzer/loganalyzer-3.6.3
Crearemos una subcarpeta dentro de la carpeta www de Apache de nuestro servidor web con:
sudo mkdir /var/www/loganalyzer
Ahora copiaremos el contenido de la carpeta "src" a la carpeta creada con:
sudo cp -R /tmp/loganalyzer/loganalyzer-3.6.3/src/* /var/www/loganalyzer
Repetiremos la operación para la carpeta "contrib":
sudo cp -R /tmp/loganalyzer/loganalyzer-3.6.3/contrib/* /var/www/loganalyzer
stableceremos permisos de escritura para los ficheros configure.sh y secure.sh:
cd /var/www/loganalyzer
sudo chmod +x configure.sh secure.sh
Iniciaremos LogAnalyzer vía web desde cualquier PC de la red abriendo un navegador e introduciendo la URL:
http://192.168.31.156/loganalyzer
(cambiaremos "192.168.31.156 por la IP de nuestro servidor syslog)
Se iniciará LogAnalyzer, en el primer inicio dará un error al detectar que aún no ha sido configurado, pulsaremos en "here" para instalar Adisco LogAnalyzer:
Con el texto: Critical Error occured. Error, main configuration file is missing! Click here to Install Adiscon LogAnalyzer!
Se iniciará el asistente para configurar e instalar definitivamente LogAnalyzer, pulsaremos "Next":
El fichero config.php debe poderse escribir, pues en el siguiente paso el asistente de instalación de LogAnalyzer lo comprobará. De no serlo deberemos debe de establecerse los permisos apropiados con el comando linux chmod:
Introduciremos los datos de configuración, los importantes son:
• Enable User database: marcaremos "Yes".
• Database Host: IP o nombre DNS (hostname) del equipo servidor de syslog con MySQL.
• Database Port: puerto de la base de datos MySQL, por defecto 3306.
• Database Name: nombre del catálogo de MySQL que el asistente creará para LogAnalyzer, por ejemplo "loganalyzer".
• Table prefix: prefijo que se añadirá al nombre de las tablas, esto es últil si queremos usar un catálogo ya existente, así separaremos por nombre las tablas de otras existentes.
• Database User: usuario que se creará en la base de datos MySQL para uso de LogAnalyzer.
• Database Password: contraseña para el usuario anterior.
• Require user to be logged in: marcaremos "Yes".
• Authentication method: seleccionaremos "Internal authentication".
El resto de parámetros son de visualización de los log, podremos modificarlos en cualquier momento:
A continuación el asistente para instalar LogAnalyzer nos indicará que se van a crear las tablas en el catálogo de MySQLelegido, pulsaremos "Next":
Si el proceso es correcto nos indicará las tablas creadas, pulsaremos "Next":
Introduciremos ahora los datos del usuario que se creará para acceder a LogAnalyzer:
Introduciremos ahora los datos de la fuente, LogAnalyzer permite analizar y consultar varios servidores de log con syslog, por lo que ahora crearemos el acceso a nuestro servidor de syslog con Rsyslog, para ello introduciremos los siguientes datos:
• Name of the Source: nombre del origen, por ejemplo "Log AjpdSoft", este nombre se usará para diferenciar varios servidores de log con syslog.
• Source Type: seleccionaremos "MYSQL Native".
• Select View: seleccionaremos "Syslog Fields".
• Table type: seleccionaremos "MonitorWare".
• Database Host: introduciremos la IP o nombre DNS de nuestro servidor con Rsyslog y MySQL.
• Database Name: introduciremos el nombre del catálogo que contiene las tablas de Rsyslog, por defecto "Syslog".
• Database Tablename: nombre de la tabla con los eventos de Rsyslog en MySQL, por defecto "SystemEvents".
• Database User: nombre de usuario de MySQL con permisos de acceso a las tablas de Rsyslog, por defecto "rsyslog".
• Database Password: contraseña del usuario anterior.
• Enable Row Counting: si vamos a tener un servidor de log con no demasiados eventos podremos marcar "Yes", si vamos a tener cientos de miles de eventos no es recomendable activar esta opción pues puede ralentizar el acceso.
•
De esta forma LogAnalyzer permite tener sus propias tablas alojadas en un servidor de MySQL diferente al de Rsyslog (o puede ser el mismo como en nuestro caso):
El proceso de instalación de LogAnalyzer habrá concluido:
Introduciendo la URL en un navegador:
http://192.168.250.156/loganalyzer
(cambiaremos "192.168.250.156 por la IP de nuestro servidor syslog)
Nos solicitará usuario y contraseña, introducimos el elegido en el proceso de instalación y pulsamos en "Login":
Y ya tendremos acceso a la consulta avanzada de los log generamos por nuestro servidor de syslog con Rsyslog desde LogAnalyzer:
Anexo
• Si se produce el error: ERROR: At least one file or directory (or more) is not writeable, please check the file permissions (chmod 666)! al intentar instalar LogAnalyzer se deben revisar los permisos de la carpeta /var/www/loganalyzer, en concreto los de los ficheros configure.sh, secure.sh y config.php.
• Si se produce algún error de falta de permisos para algún usuario de MySQL tal vez sea necesario asignarle permisos, una forma para hacerlo es desde la línea de comando de Linux, con los comandos:
mysql -u root -p
grant all privileges on Syslog.* to 'rsyslog'@'%' with grant option;
proximo tema... comprendiendo el archivo de configuración de rsyslog

12
Linux/netplan_ip_static.txt Normal file
View File

@ -0,0 +1,12 @@
cat /etc/netplan/00-installer-config.yaml
network:
ethernets:
ens33:
addresses: [192.168.1.10/24]
gateway4: 192.168.1.1
nameservers:
addresses: [208.67.222.222,208.67.220.220]
version: 2
sudo nano /etc/netplan/00-installer-config.yaml
sudo netplan apply

75
Linux/nfs.txt Normal file
View File

@ -0,0 +1,75 @@
#########
SERVIDOR
#########
Instalamos el servidor NFS en un ordenador de nuestra red:
sudo apt-get install nfs-kernel-server
Vamos a compartir un directorio general y el home
Creamos un directorio para exportar como nfs:
sudo mkdir /var/nfs/general -p
NFS traducirá cualquier operación root sobre el cliente a las credenciales nobody:nogroup como medida de seguridad.
Por tanto, debemos cambiar la propiedad del directorio para que coincida con esas credenciales:
sudo chown nobody:nogroup /var/nfs/general
El directorio /home ya existe por lo que no lo crearemos, tampoco le cambiamos los permisos, ya que tiene los adecuados.
Editamos el archivo /etc/exports y escribimos:
/var/nfs/general 192.168.0.0/24(rw,sync,no_subtree_check)
/home 192.168.0.37(rw,sync,no_root_squash,no_subtree_check)
Esto comparte el directorio general en toda la red 192.168 y el home a un solo equipo
Permisos que se pueden aplicar:
ro : lectura
rw : lectura y escritura
link_relative : convierte los enlaces simbólicos absolutos en enlaces simbólicos relativos.
link_absolute : Lo contrario, de relativos a absolutos. Esta es la opción predeterminada.
root_squash : trata las consultas como si vinieran del usuario nobody (lo más seguro). O sea, que evitamos que los usuarios conectados actúen como root.
no_root_sqash : Desactiva lo anterior, y por tanto implica algo de riesgo porque habilita los privilegios de root.
all_squash : Realiza la acción root_squash para todos los usuarios, incluido los usuarios root.
no_all_squash : Habilita la autorización del usuario.
Exportamos el directorio compartido con:
sudo exportfs -a
Parámetros interesantes de exportfs:
exportfs -v : muestra una lista de recursos compartidos y sus opciones configuradas en el archivo /etc/exports
exportfs -a : Exporta todos los directorios declarados en el archivo /etc/exports
exportfs -u : Sirve para des-exportar uno o más recursos.
exportfs -r : re-exporta los directorios después de modificar el archivo /etc/exports
Ahora reinicimos el servidor NFS:
sudo systemctl restart nfs-kernel-server
Ajustamos el firewall:
sudo ufw allow from 192.168.0.0/24 to any port nfs
#########
CLIENTE
#########
En el ordenador cliente instalamos nfs-common:
sudo apt-get install rpcbind nfs-common
Añadimos una línea al archivo /etc/hosts.deny:
rpcbind : ALL
Y otra al archivo /etc/hosts.allow:
rpcbind : ip-del-servidor
Creamos un directorio llamado directorio-red para montar en él el directorio home del servidor:
mkdir directorio-red
Montamos el directorio donde deseemos con:
sudo mount ip-del-servidor:/home /home/usuario/directorio-red
Vemos si está montado:
mount -t nfs
Para que el directorio-red se monte automáticamente al iniciar el sistema operativo, abrimos el archivo /etc/fstab y escribimos al final la siguiente línea (suponemos que el servidor nfs es 192.168.1.8):
ip-del-servidor:/home /home/usuario/directorio-red nfs auto,noatime,nolock,bg,nfsvers=4,intr,tcp,actimeo=1800 0 0
Si alguna vez queremos desmontar este directorio de red:
sudo umount /home/usuario/directorio-red
y luego eliminamos la línea añadida previamente al archivo /etc/fstab

52
Linux/openFire en Linux HowTo.txt Normal file
View File

@ -0,0 +1,52 @@
Necesitamos tener un Servidor LAMP, por ejemplo:
sudo apt-get install apache2 mysql-server php5
Si ya tenemos el servidor LAMP montado vamos a asegurarnos que tenemos el sistema actualizado.
sudo apt-get update
sudo apt-get upgrade
Una vez hecho esto vamos a instalar Java
sudo apt-get install python-software-properties
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
Si estas usando OpenJDK, desinstalalo para reducir conflictos con Java
sudo apt-get remove --purge openjdk*
Ahora instalamos Java 7 de Oracle
sudo apt-get install oracle-java7-installer
Instalamos si no lo tenemos la ultima version de MySQL server (esto solo si no hemos instalado LAMP)
sudo apt-get install mysql-server
Nos logamos como root en mysql y creamos la base de datos y el usuario a los que tengais phpmyadmin podeis hacerlo desde alli.
sudo mysql -u root p
mysql> CREATE DATABASE dbopenfire CHARACTER SET='utf8';
mysql> CREATE USER 'openfire'@'localhost' IDENTIFIED BY 'openfirepwd';
mysql> GRANT ALL PRIVILEGES ON dbopenfire.* TO openfire@localhost WITH GRANT OPTION;
mysql> FLUSH PRIVILEGES;
mysql> quit
Descargamos e instalamos la ultima version de OpenFire
cd /tmp
wget http://download.igniterealtime.org/openfire/openfire_3.8.1_all.deb
Instalamos Openfire con el comando dpkg
sudo dpkg -i openfire_3.8.1_all.deb
Ignoramos los errores que da la instalación sobre permisos, ya que eso depende de la version de JRE/jdk/ y seguimos, pues necesitamos editar el fichero /etc/init/d/openfire linea 27. Sustituir java-6-sun con java-6-oracle or java-7-oracle.
sudo apt-get install rpl
sudo rpl '6-sun' '7-oracle' /etc/init.d/openfire
sudo service openfire start
Ahora vamos a habilitamos los puertos para Openfire. Tened en cuenta que necesitamos configurar el cortafuegos (firewall) y habilitar los puertos para openfire en el servidor Ubuntu, para ello usamos el comando "ufw" para configurar Openfire Firewall.
sudo ufw allow 9090/tcp
sudo ufw allow 9091/tcp
sudo ufw allow 5222/tcp
sudo ufw allow 7777/tcp
sudo ufw allow 7443/tcp
sudo ufw allow 7070/tcp
sudo ufw allow 3478/tcp
sudo ufw allow 3479/tcp
Con esto hemos completado los pasos iniciales de la instalacion de OpenFire. Ahora vamos a seguir con la configuración a través de un navegador web.
Configurando Openfire Server:
Configurar Openfire es muy sencillo y se hace en un par de pasos, desde nuestro navegador web vamos a la siguiente direccion
http://tudominio-o-ip-o-localhost:9090/setup/index.jsp
Contestamos a las preguntas que nos va solicitando, recomiendo dejar los puertos por defecto y listo.
Ahora resetamos OpenFire para que se aplique todo
sudo /etc/init.d/openfire restart
Recuerda que para administrar y configurar el Servidor Jabber de OpenFire debemos poner en el navegador web.
http://tudominio.es:9090
http://laipdelserver:9090 Si es en una red local.
http://localhost:9090 Si estas en el ordenador que hace de servidor.

38
Linux/openssl.txt Normal file
View File

@ -0,0 +1,38 @@
Convertir CER a CRT:
openssl x509 -inform DER -in certificatename.cer -out certificatename.crt #.cer es binario hay que usar -inform DER
openssl x509 -inform PEM -in certificatename.cer -out certificatename.crt #.cer es x509 base64 hay que usar -inform PEM
Convertir CER (binario) a PEM
openssl x509 -inform DER -in certificatename.cer -outform PEM -out certificatename.pem
Convertir PEM a DER
openssl x509 -inform PEM -in certificatename.pem -outform DER -out certificatename.der
Convertir DER a PEM
openssl x509 -inform DER -in certificatename.der -outform PEM -out certificatename.pem
Convertir PEM a P7B
openssl crl2pkcs7 -nocrl -certfile certificatename.pem -out certificatename.p7b -certfile CACert.cer
Note: The PKCS#7 or P7B format is sared in Base64 ASCII format and has a file extension of .p7b or .p7c.
A P7B file only contains certificates and chain certificates (Intermediate CAs), not the private key.
The most common platforms that support P7B files are Microsoft Windows and Java Tomcat.
Convertir PKCS7 a PEM
openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.pem
Convertir PFX a PEM
openssl pkcs12 -in certificatename.pfx -out certificatename.pem
Note: The PKCS#12 or PFX format is a binary format for saring the server certificate, intermediate certificates, and the private key in one encryptable file. PFX files usually have extensions such as .pfx and .p12. PFX files are typically used on Windows machines a import and export certificates and private keys.
Convertir PFX a PKCS#8
PASO 1: Convertir PFX a PEM
openssl pkcs12 -in certificatename.pfx -nocerts -nodes -out certificatename.pem
PASO 2: Convertir PEM a PKCS8
openSSL pkcs8 -in certificatename.pem -apk8 -nocrypt -out certificatename.pk8
Convertir P7B a PFX
PASO 1: Convertir P7B a CER
openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.cer
PASO 2: Convertir CER and Private Key a PFX
openssl pkcs12 -export -in certificatename.cer -inkey privateKey.key -out certificatename.pfx -certfile cacert.cer

59
Linux/php8.0 a php8.1.txt Normal file
View File

@ -0,0 +1,59 @@
apt install php8.1 php8.1-bcmath php8.1-cli php8.1-common php8.1-curl php8.1-dev php8.1-fpm php8.1-gd php8.1-igbinary php8.1-intl php8.1-ldap php8.1-mbstring php8.1-mysql php8.1-opcache php8.1-phpdbg php8.1-readline php8.1-soap php8.1-sqlite3 php8.1-xml php8.1-xmlrpc php8.1-xsl php8.1-zip
sed 's/user = www-data/user = nginx/g' -i /etc/php/8.1/fpm/pool.d/www.conf
sed 's/group = www-data/group = nginx/g' -i /etc/php/8.1/fpm/pool.d/www.conf
sed 's/listen.owner = www-data/listen.owner = nginx/g' -i /etc/php/8.1/fpm/pool.d/www.conf
sed 's/listen.group = www-data/listen.group = nginx/g' -i /etc/php/8.1/fpm/pool.d/www.conf
grep nginx /etc/php/8.1/fpm/pool.d/www.conf
cp /etc/php/8.0/fpm/conf.d/99-php_cnmc.ini /etc/php/8.1/mods-available/php_cnmc.ini
ln -s /etc/php/8.1/mods-available/php_cnmc.ini /etc/php/8.1/fpm/conf.d/99-php_cnmc.ini
ls -la /etc/php/8.1/fpm/conf.d/
update-alternatives --set php /usr/bin/php8.1
php -v
pecl uninstall -r sqlsrv
pecl uninstall -r pdo_sqlsrv
pecl -d php_suffix=8.1 install sqlsrv
pecl -d php_suffix=8.1 install pdo_sqlsrv
printf "; priority=20\nextension=sqlsrv.so\n" > /etc/php/8.1/mods-available/sqlsrv.ini
printf "; priority=30\nextension=pdo_sqlsrv.so\n" > /etc/php/8.1/mods-available/pdo_sqlsrv.ini
phpenmod -v 8.1 sqlsrv pdo_sqlsrv
systemctl stop php8.1-fpm
systemctl start php8.1-fpm
systemctl status php8.1-fpm
php -i | grep -i sqlsrv
php -v
grep php8.0-fpm.sock /etc/nginx/conf.d/*.conf
sed 's/php8.0-fpm.sock/php8.1-fpm.sock/g' -i /etc/nginx/conf.d/*.conf
grep php8.1-fpm.sock /etc/nginx/conf.d/*.conf
nginx -s reload
systemctl stop php8.0-fpm
systemctl disable php8.0-fpm

151
Linux/puTTY sessions list from Windows to Linux.txt Normal file
View File

@ -0,0 +1,151 @@
Transfer PuTTY sessions list from Windows to Linux
Step 1: Download pwin2lin.pl on Linux.
# wget https://pwin2lin.googlecode.com/files/pwin2lin.pl
Step 2: Install PuTTY on Linux.
# wget http://the.earth.li/~sgtatham/putty/latest/putty-0.63.tar.gz
# tar zxvf putty-0.63.tar.gz
# cd putty-0.63/
# ./configure
# make; make install
Step 3: Export Windows registry containing PuTTY sessions.
E:\Linux>regedit /e "E:\Linux\putty.reg" "HKEY_CURRENT_USER\Software\SimonTatham\PuTTY"
Step 4: Import to Linux.
$ cp /media/sf_Linux/putty.reg .
$ ll putty.reg
-rwxr-x--- 1 oracle dba 15376 Jun 6 21:05 putty.reg
$ ./pwin2lin.pl ./putty.reg ~/.putty
$ mkdir /home/oracle/.putty
$ mkdir /home/oracle/.putty/sessions
$ cd .putty/sessions/
$ ll
total 8
-rw-r--r-- 1 oracle dba 4257 Jun 6 21:06 rac01
############################ pwin2lin.pl ########################################################
#!/usr/bin/perl -w
# Dan Witt
# 5/28/2010
# Convert Windows PuTTY sessions to Linux
#How to use pwin2lin.pl
sub help {
print<<HELP
Export the PuTTY registry settings from Windows:
Start->Run->regedit
HKEY_CURRENT_USER\\Software\\SimonTatham\\
Right click PuTTY and choose 'Export'. Save the registry file to your Linux machine and run this script from a shell (chmod 755 first):
./pwin2lin.pl
Examples:
Running the script alone:
foo\@bar:~\$ ./pwin2lin.pl
Specify files from the command line:
foo\@bar:~\$ ./pwin2lin.pl myPuttySessions.reg /home/foo/.putty
HELP
}
# Includes
use Encode;
use File::Path;
use strict;
# Globals
my $winRegFile = "";
my $puttyPath = "";
if($#ARGV + 1) { # If any command line arguments are specified try to parse
if($ARGV[0] eq "--help") {
&help();
exit;
} elsif($ARGV[0] && $ARGV[1]) {
$winRegFile = $ARGV[0];
chomp $winRegFile;
$puttyPath = $ARGV[1];
chomp $puttyPath;
} else {
print "Usage:\n ./pwin2lin.pl [Windows Reg File] [Path to save PuTTY sessions]\n ./pwin2lin.pl --help\n";
exit;
}
} else { # Ask them where the registry file is and where they'd like to store the converted sessions.
print "Specify the path and file to convert:\n";
$winRegFile = <STDIN>;
chomp $winRegFile;
print "Specify the path to store the converted sessions:\n";
$puttyPath = <STDIN>;
chomp $puttyPath;
$puttyPath = "./" if !$puttyPath;
}
# Open the file and convert it from UTF-16LE
open(FILE, "<:encoding(UTF-16LE):crlf", $winRegFile) or die $!;
my @lines = <FILE>;
close FILE;
mkpath "$puttyPath/sessions", 0740 unless -d "$puttyPath/sessions";
my $linesLen = scalar @lines;
# Parse the registry file, try to guess some settings
my $i = 0;
while($i < $linesLen) {
chomp $lines[$i];
if($lines[$i] =~
m/^\[HKEY_CURRENT_USER\\Software\\SimonTatham\\PuTTY\\Sessions\\(.+)\]/)
{
my $hostname = $1;
$i++;
next if $hostname =~ m/^Default.+Settings$/; # Use Linux Defaults
#print "$hostname\n";
open HOST, ">$puttyPath/sessions/$hostname" or die $!; # Write out the session
while(1) {
chomp $lines[$i];
last if $lines[$i] eq "";
$lines[$i] =~ s/\"//g;
if($lines[$i] =~ m/dword:(.+)/) {
my $dec = $1;
if($dec eq "ffffffff") {
$dec = -1;
} else {
$dec = hex($dec);
}
$lines[$i] =~ s/dword:.+/$dec/g;
}
$lines[$i] =~ s/^Font\=.+/FontName=server:fixed/g;
$lines[$i] =~ s/^NoRemoteQTitle\=(.+)/RemoteQTitleAction\=$1/g;
$lines[$i] =~ s/^SerialLine\=.+/SerialLine\=\/dev\/ttyS0/g;
$lines[$i] =~ s/^FontVTMode\=.+/FontVTMode\=4/g;
#print "$lines[$i]\n";
print HOST "$lines[$i]\n";
$i++;
}
close HOST;
} elsif($lines[$i] =~
m/\[HKEY_CURRENT_USER\\Software\\SimonTatham\\PuTTY\\SshHostKeys\]/) {
$i++;
open SSH, ">$puttyPath/sshhostkeys" or die $!;
while($i < $linesLen) {
chomp($lines[$i]);
$lines[$i] =~ s/\"//g;
print SSH "$lines[$i]\n";
$i++;
}
close SSH;
}
$i++;
}

71
Linux/radius ubuntu - centos - oracle.txt Normal file
View File

@ -0,0 +1,71 @@
En este procedimiento se describirá los pasos a seguir para poder autenticarse en maquinas con sistema operativo Ubuntu, CentOS u Oracle con usuarios del directorio Activo.
Configuración del servidor con sistema operativo Ubuntu.
Instalación de paquetes.
UBUNTU:
apt-get -y install libpam-radius-auth
CENTOS:
sudo yum install epel-release
sudo yum update
sudo yum install pam_radius
ORACLE LINUX:
sudo wget http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
sudo rpm -ivh epel-release-6-8.noarch.rpm
sudo yum install pam_radius
ORACLE LINUX 7:
sudo yum install -y wget
sudo wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
sudo yum install epel-release-latest-7.noarch.rpm
sudo yum install -y pam_radius
Creación de usuarios
Para que la autenticacion contra el directorio activo funcione se debe crear un usuario local con el mismo nombre de inicio de sesión.
sudo useradd usuario -c "Apellidos, Nombre" -m -s /bin/bash
Edición de Archivos.
/etc/pam_radius_auth.conf
#añadimos la linea con la ip del servidor radius y la clave secreta (IP [clave compartida] 3)
127.0.0.1 secret 1
IP [clave compartida] 3
other-server other-secret 3
/etc/pam.d/sshd
#Añadimos la siguiente linea en el grupo de lineas con auth
UBUNTU:
auth sufficient pam_radius_auth.so
CENTOS / ORACLE:
auth sufficient /usr/lib64/security/pam_radius_auth.so
/etc/pam.d/sudo
Aunque configuremos este archivo y el archivo /etc/pam.d/su para que los usuario puedan hacer sudo y su con sus cuentas del directorio activo deberemos añadir a dichos usuario o grupos locales de la maquina al archivo /etc/sudoers
#Añadimos la siguiente linea antes de los @include common-auth y demás
UBUNTU:
auth sufficient pam_radius_auth.so
CENTOS / ORACLE:
auth sufficient /usr/lib64/security/pam_radius_auth.so
/etc/pam.d/su
#Añadimos la siguiente linea antes de los @include common-auth y demás
UBUNTU:
auth sufficient pam_radius_auth.so
CENTOS / ORACLE:
auth sufficient /usr/lib64/security/pam_radius_auth.so
Hay casos en los que el servidor al ejecutar el comando "su" pide dos veces la autenticación, si esto pasa, para solucionarlo habrá que deshacer este paso.
/etc/ssh/sshd_config
#En caso de que este fichero tenga descomentada la linea AllowGroups , hay que añadir el grupo de administradores
...
AllowGroups ... grupoadmin
...
Creación de clientes en el servidor RADIUS
Una vez hemos accedido al servidor radius (Windows) en Network Policy Server hacemos boton derecho sobre RADIUS Clients | New.
En la pantalla que nos aparecerá debemos rellenar los siguientes campos:
Friendly name: Nombre del cliente, en nuestro caso lo mas recomendable seria el nombre de la maquina.
Address (IP or DNS): IP o DNS de la maquina que queremos añadir.
Shared Secret: Introducir la contraseña compartida.

37
Linux/rbash - limitar comandos a usuario.txt Normal file
View File

@ -0,0 +1,37 @@
Hay veces que por los motivos que sean un usuario tiene que tener acceso a un sistema y en él sólo debería de poder permanecer en su ~home y también debería de sólo poder ejecutar los comandos que se le indiquen. Esto funciona muy bien excepto por la curiosidad. Si un usuario tiene acceso a algo, intentará tarde o temprano verlo. Entonces... ¿cómo podemos evitar al usuario cotilla? La respuesta es sencilla, realizando una jaula chroot para su sesión y que no pueda salir de ella ni ejecutar comandos fuera de los que le estén permitidos. A continuación os voy a enseñar cómo montar un sistema 'chroot' y lo pongo entre comillas, por que realmente no es en sí una jaula propiamente dicha.
Partimos de que necesitamos crear un usuario test que sólo tenga acceso al sistema para realizar un telnet a otra máquina de la red. Puesto que únicamente necesita ejecutar un telnet necesitamos restringir el resto de comandos disponibles en una sesión bash normal. Vamos a ir paso a paso configurando todo.
Creamos el usuario test
Este será un usuario normal del sistema, así que lo creamos como un usuario normal. La única peculiaridad es que cambiamos la shell de dicho usuario. Por defecto suele ser /bin/bash y vamos a establecer /bin/rbash. rbash es realmente una copia de bash, pero realmente es un "restricted bash".
shell> adduser --shell /bin/rbash test
Creamos el fichero .bash_profile
Hay que crear este fichero en la home del usuario que se ha creado y para el que queremos aplicar los permisos. El contenido del fichero será el que sigue,
if [ -f ~/.bashrc ]; then
. ~/.bashrc
fi
PATH=$HOME/apps
export PATH
Evitamos las modificaciones
Cuando ya tengamos el fichero creado, impedimos que nadie pueda realizar modificaciones en el fichero.
shell> chattr +i /home/test/.bash_profile
Creamos el directorio de apps e instalamos los programas con 'acceso'
Ahora una vez que tenemos ya todo configurado sólo queda crear el directorio apps y dentro de él, crear un link a los programas que deseamos que el usuario tenga permisos. Todos los programas que estén dentro de apps, el usuarios los podrá ejecutar, sino, no.
shell> mkdir apps
shell> ln -s /usr/bin/telnet /home/test/apps/
Comprobamos que funciona
Accedemos al sistema y comprobamos que funciona correctamente.
shell> ssh test@remote
test@remote's password:
shell@remote> ls
-rbash: ls: no se encontró la orden
shell@remote> cd
-rbash: cd: no se encontró la orden
shell@remote> telnet
telnet>

47
Linux/recuperar la contraseña de root - howto extendido.txt Normal file
View File

@ -0,0 +1,47 @@
Cómo recuperar el password de root
La semana pasada se me acercó un amigo y me preguntó "Emi, me olvidé el password de root, ¿me ayudás a recuperarlo?" a lo que yo respondí: "no hay problema, sólo hace falta iniciar el sistema en single user mode". Muy bonito, pero del dicho al hecho hay mucho trecho.
Antes de iniciar en modo single user conviene hacer un par de pruebas básicas.
Primero se puede tratar de verificar si root no está logueado actualmente en alguna otra TTY (no es poco frecuente que suceda si se trata de un servidor, a veces queda alguna sesión "olvidada" por ahí). Ver la salida del comando w y alternar entre diferentes TTY utilizando las combinaciones de teclado Ctrl+Alt+F*.
Segundo, ver si el usuario actual (o algún otro usuario) tiene permiso para ejecutar sudo su -. Parece trivial, pero en la desesperación tal vez no nos damos cuenta que algún otro usuario tiene sudo. El comando sudo permite ejecutar comandos como superusuario, pero autenticando al usuario actual utilizando su propia contraseña (en lugar de utilizar la contraseña de root).
Si logramos acceder por alguno de estos dos métodos es posible resetear la contraseña de root ejecutando passwd, aunque también es posible volcar el contenido del archivo "/etc/shadow" y utilizar el famoso John the Ripper para tratar de determinar cual era la contraseña olvidada. Más adelante prometo escribir algún artículo dedicado a "John the Ripper".
¿Qué es el modo single user?
El modo single user es un modo en el cual un sistema operativo multiusario inicia en un único usuario privilegiado (superusuario) como si se tratase de un sistema operativo monousuario. Este modo se utiliza principalmente para tareas de mantenimiento de entornos multiusuario (para ejecutar tareas que requieren acceso exclusivo a los recursos, por ejemplo cuando se necesita ejecutar fsck sobre un disco compartido), o por razones de seguridad (ya que no se inician los servicios de red). En algunos sistemas (por ejemplo Linux) es posible cambiar una contraseña de root olvidada o perdida cambiando a modo single user, aunque no solicitar el password en tal circunstancia es considerado como una vulnerabilidad de seguridad.
Los sistemas operativos de la familia Unix proveen la funcionalidad single user mode a través de los runlevels estilo System V, a través de opciones del bootloader estilo BSD, o a través de otras opciones de booteo. Los runlevels se cambian utilizando el comando init. Los runlevels 1 ó S inician el sistema en modo single user. Aunque sin privilegios suficientes, es imposible cambiar el runlevel utilizando el comando init, por ello hace falta reiniciar el sistema y cambiar las opciones del bootloader durante el inicio, antes de que se ejecute el kernel.
¿Cómo iniciar Linux en single user mode?
Para iniciar en modo single user es necesario reiniciar el sistema y acceder al bootloader (LILO o GRUB). Si durante el inicio no se observa una pantalla de booteo de LILO o GRUB se puede intentar acceder presionando la combinación de teclas Ctrl+X.
Si se trata de LILO, sólo es necesario escribir el comando linux single (asumiendo que "linux" es la etiqueta del kernel que deseamos iniciar). Si se trata de GRUB, se debe presionar la tecla e ("edit") sobre la línea correspondiente al kernel que deseamos iniciar, posicionarse en la línea que comienza con "kernel" y presionar e nuevamente, agregar el comando single (ó 1) al final de la línea (dejando un espacio en blanco antes de insertar "single" ó "1"), presionar enter para finalizar la edición y finalmente b ("boot") para iniciar el sistema en modo single user.
Nota: en GRUB esta edición no es persistente, por lo que no hay que preocuparse por cometer errores. Lógicamente si se desea iniciar nuevamente en modo single user será necesario repetir el procedimiento.
El sistema inicia con una secuencia de booteo normal excepto que termina rápidamente dejando abierto un prompt bash (el prompt o command prompt es la secuencia de uno o más caracteres que se utiliza en la interfaz de la línea de comandos para indicar que el intérprete está listo para recibir órdenes, es decir comandos). Al finalizar con el caracter #, el prompt indica que se trata del usuario root (o superusuario).
Si en lugar de dejar un prompt de root se recibe un mensaje solicitando el password de root para realizar tareas de mantenimiento, significa que el sistema está configurado para solicitar el password de root cuando se ingresa a single user mode. En este caso se debe intentar un truco que consiste en reemplazar el proceso init con /bin/bash (el intérprete de comandos).
Si el sistema no solicita en password de root y termina dejando abierto el prompt bash, es posible resetear el password de root utilizando eel comando passwd. Si funciona significa que se ha podido cambiar la contraseña de root de forma exitosa. Ahora es posible reiniciar el sistema y continuar leyendo las últimas entradas en linuxito.com (o las últimas actualizaciones de Justin Beaver en facebook, lo que sea de mayor agrado). También sería útil pensar en configurar sudo para la próxima vez.
Si el comando passwd no funciona, puede que el sistema de archivos raíz (/) no esté montado con permiso de escritura (rw). Remontar el sistema de archivoz raíz de la siguiente forma:
mount -o remount,rw /
O también, suponiendo que el sistema de archivos raíz se encuentra en el dispositivo "/dev/sda2" (para determinar en qué dispositivo se encuentra es posible utilizar los comandos mount y fdisk -l, o volcar el contenido del archivo "/etc/fstab"):
mount -o remount,rw /dev/sda2
Puede que el comando mount reporte que el sistema de archivos raíz está montado rw a pesar de que no sea así, por lo tanto es conveniente probar de todos modos. Una vez remontado el sistema de archivos raíz utilizar el comando passwd nuevamente. Si es necesario especificar el tipo de sistema de archivos, utilizar la opción -t (por ejemplo si se trata de "ext4"):
mount -o remount,rw -t ext4 /dev/sda2
¿Qué hacer si el sistema solicita el password de root para pasar a single user mode?
Un truco simple es reemplazar init por "/bin/bash". Una vez que el kernel inicie en lugar de crear el proceso init abrirá una instancia de bash. Para ello es necesario ejecutar linux init=/bin/bash en LILO o agregar init=/bin/bash en la línea "kernel" de GRUB.
Debido a que este método de inicio termina en un prompt bash mucho antes que en modo single user, menor cantidad de subsistemas serán inicializados, menos dispositivos serán montados, etc. Tal vez sea necesario montar el resto de los filesystems (al menos los que sean necesarios) de forma manual (revisar el archivo "/etc/fstab" o ejecutar fdisk -l para listar las particiones disponibles). Muy posiblemente será necesario remontar el sistema de archivos raíz en modo rw antes de poder ejecutar passwd.
¿Qué hacer si el bootloader está protegido con contraseña?
A veces (sobre todo si se trata de un sistema que no nos pertenece o que no hemos instalado) el bootloader está protegido con contraseña, es decir que no se podrá ingresar en modo single user sin conocer la contraseña del bootloader.
En este este escenario la única alternativa es iniciar desde un medio removible, siempre que el hardware lo permita (permita bootear desde un medio removible).
Es posible utilizar un LiveCD, aunque algunas distribuciones modernas poseen un modo de recuperación del sistema (por ejemplo "linux rescue") en el mismo DVD de instalación. Cuando se utiliza el modo de recuperación generalmente es necesario ejecutar chroot antes de poder utilizar el comando passwd, ya que el sistema de archivos raíz suele quedar montado en otra rama del árbol, por ejemplo "/mnt/sysimage". El procedimiento es similar cuando se utiliza un LiveCD de otra distribución: primero se monta el dispositivo que contiene el sistema de archivos raíz en cualquier rama (en modo rw); luego se hace un chroot a esa rama; y finalmente se ejecuta passwd.
¿Y si el bootloader está protegido con contraseña y no es posible bootear desde un medio removible?
Si no se permite bootear desde un medio removible (porque no lo permite la configuración del hardware), tal vez la única alternativa sea remover el disco rígido y conectarlo a otro sistema. Luego desde este sistema se puede montar el sistema de archivos raíz y editar el archivo "/etc/shadow" para eliminar el password de root.
Para eliminar o borrar el password de root buscar la línea correspondiente a "root":
root:$1$xhzFdvur$I.8IJ.Py7sJ5oHJQk/dXs1:15049:0:99999:7:::
Luego vaciar la segunda columna, la cual corresponde al hash del password, debe quedar así:
root::15049:0:99999:7:::
De esta forma se permite autenticar al usuario root sin utilizar contraseña. Por supuesto se debe asignar inmediatamente un nuevo password a root cuando se reinicie el sistema.
¿Qué pasa cuando el disco rígido está encriptado?
Si el disco rígido está encriptado, por ejemplo utilizando LUKS (Linux Unified Key Setup), y no se posee la clave de encriptación, sólo queda hacer fuerza bruta (buena suerte en esa empresa).
Espero que les haya gustado y sirva para "salvar las papas" en alguna ocasión.

26
Linux/recuperar la contraseña de root DEBIAN 8.txt Normal file
View File

@ -0,0 +1,26 @@
Edit GRUB before Debian boot
During you machine boot process, you should be presented with GNU GRUB screen with countdown, before the default boot option is activated.
Press any key during the countdown period stop the boot process, and then press e key to edit the commands before booting.
One you have entered into editing mode, find the line starting with linux, followed by /boot/vmlinuz-*, and containing section with root=UUID=.
Line should be towards the end, usually two lines before the final line.
On the end of that line, in most case after ro quiet, add one of the following two: init=/bin/bash or init=/bin/sh, as shown on picture below.
After you have added the init value, press Ctrl+x or F10 key to boot the with the selected options.
Debian should now boot to single user mode, with the root filesystem mounted in read-only mode.
You need to remount it to read-write mode with the following command:
mount -n -o remount,rw /.
After that you can use passwd command to change the root password to a new value.
Type passwd to be asked for a new password, and then reenter the new password again, once asked to retype it, and you should then be presented with following message:
passwd: password updated successfully
You can now reboot your machine, and use the new root password on your system.

26
Linux/recuperar la contraseña de root.txt Normal file
View File

@ -0,0 +1,26 @@
¿Cómo recuperar la contraseña de root?
Para recuperar la contraseña del root desde el GRUB, basta con editar la linea de boot y agregar single al final, luego botear y ya estas como root. Ahi lo que haces es escribir: passwd para cambiar la contraseña.
El procedimiento con GRUB sería:
1- reiniciar el equipo
2- Al presentar la ventana para seleccionar el sistema operativo, nos colocamos en la que corresponde a nuestra distribución pulsamos ‘e’ para entrar al modo de edición.
3- En la siguiente ventana veremos varias líneas, que son los argumentos con los que inicia el sistema, nos colocamos en la que inicia con ‘kernel’ y pulsamos ‘e’ para editarla.
4- En la ventana subsecuente separamos con un espacio el texto precedente y escribimos ‘single’ para iniciar en modo monousuario. Pulsamos enter al terminar.
5- Debemos ver como se adicionó ‘single’ a la línea editada, con lo que pulsamos ‘b’ para iniciar el sistema.
6- Al entrar en modo de terminal, tenemos la cuenta del superadministrador, por lo que ya podemos cambiar la contraseña de root y reiniciamos el equipo para que tome efecto el cambio.
passwd root
reboot
Si el GRUB tiene contraseña, hay problemas, entonces toca utilizar un live cd o el primer disco de instalación (en el caso de RedHat, Fedora, y clones).
Cambiar contraseña desde el disco de instalación/rescate:
1- Iniciar con el primer disco de instalación. No importa si se trata de una versión o distribución diferente a la que está en el equipo.
2- Cuando se presente el texto boot, escribir linux rescue para entrar en modo de rescate.
3- Una vez en el prompt montar el dispositivo que tiene el sistema de archivos raiz en un directorio:
mount /dev/sda1 /mnt/sysimage
3- Una vez montado el sistema raiz en el directorio elegido realizamos un chroot para cambiar de entorno:
chroot /mnt/sysimage
4- Así, ya podemos cambiar la contraseña de root y reiniciamos el equipo para que tome efecto el cambio.
passwd root
reboot

10
Linux/recuperar resolucion monitor VGA.txt Normal file
View File

@ -0,0 +1,10 @@
INTRODUCIR LOS SIGUIENTES COMANDOS:
xrandr -q
xrandr --output VGA-1-0 --mode 1280x1024
xrandr --newmode $(gtf 1280 1024 60 | grep Modeline | sed s/Modeline\ // | tr -d '"')
xrandr --addmode VGA-1-0 1280x1024_60.00
xrandr --output VGA-1-0 --off
Y AHORA DESDE CONFIGURACION DEL SISTEMA -> PANTALLA YA DEBERIA ESTAR EL NUEVO MODO

75
Linux/recuperar una HOME cifrada desde un live cd.txt Normal file
View File

@ -0,0 +1,75 @@
Supongamos que hemos cifrado la carpeta de usuario (Trisquel y Ubuntu dan esa posibilidad al instalarlo), y por cosas de la vida perdemos la posibilidad de acceder al SO, pero seguimos teniendo acceso a la particion con los datos ( y la clave, se entiende ). Esto es lo que podríamos hacer desde un LiveCD para volver a montar la partición:
Nota: substituye $DRIVE por la ruta hacia la particion home + .ecryptfs, por ejemplo sería /media/blablabla/.ecryptfs/
[ 1 ] Obtener clave del sistema de cifrado, contenida en $DRIVE/<nombre de usuario>/.ecryptfs/wrapped-passphrase , y envuelta con la contraseña del usuario.
$ ecryptfs-unwrap-passphrase $DRIVE/<nombre de usuario>/.ecryptfs/wrapped-passphrase
Passphrase: # Aqui la clave del usuario
e25c829b60e65e63a1ec2b9581ae4d4a
Entonces e25c829b60e65e63a1ec2b9581ae4d4a sería la clave con la que se cifraron los datos, pero queda otra, a partir de Ubuntu 9.04 se cifran por defecto tambié los nombres de archivo.
[ 2 ] Obtener la clave que cifra los nombres de los archivos.
$ ecryptfs-add-passphrase --fnek
Passphrase: # La clave que acabamos de obtener
Inserted auth tok with sig [b6829c7b365a3b16] into the user session keyring
Inserted auth tok with sig [b906f5e58bfbce18] into the user session keyring
La segunda, b906f5e58bfbce18, es la que cifra los nombres de los archivos.
[ 3 ] Montar el sistema de archivos.
$ sudo mount -t ecryptfs $DRIVE/<nombre de usuario>/.Private/ /home/<nombre de usuario>/
Passphrase: # Clave de cifrado de los archivos
Select cipher:
1) aes: blocksize = 16; min keysize = 16; max keysize = 32 (not loaded)
2) blowfish: blocksize = 16; min keysize = 16; max keysize = 56 (not loaded)
3) des3_ede: blocksize = 8; min keysize = 24; max keysize = 24 (not loaded)
4) cast6: blocksize = 16; min keysize = 16; max keysize = 32 (not loaded)
5) cast5: blocksize = 8; min keysize = 5; max keysize = 16 (not loaded)
Selection [aes]: aes # Por defecto
Select key bytes:
1) 16
2) 32
3) 24
Selection [16]: 16 # Por defecto
Enable plaintext passthrough (y/n) [n]: n # Por defecto
# Atencion a partir de aqui ;)
Enable filename encryption (y/n) [n]: y # Si, desde la Ubuntu 9.04 los nombres de archivo están cifrados
Filename Encryption Key (FNEK) Signature [b6829c7b365a3b16]: b906f5e58bfbce18 # Clave de cifrado de los nombres
Attempting to mount with the following options:
ecryptfs_unlink_sigs
ecryptfs_fnek_sig=b906f5e58bfbce18
ecryptfs_key_bytes=16
ecryptfs_cipher=aes
ecryptfs_sig=b6829c7b365a3b16
WARNING: Based on the contents of [/root/.ecryptfs/sig-cache.txt],
it looks like you have never mounted with this key
before. This could mean that you have typed your
passphrase wrong.
Would you like to proceed with the mount (yes/no)? : yes # Para montarlo aunque no esté entre las claves utilizadas
Would you like to append sig [b6829c7b365a3b16] to [/root/.ecryptfs/sig-cache.txt]
in order to avoid this warning in the future (yes/no)? : yes # Para que no muestre que es una clave nueva si lo montamos otra vez
Successfully appended new sig to user sig cache file
Mounted eCryptfs
Ya está!
EJEMPLO REAL REALIZADO POR MI MISMO PARA RECUPERAR EL HOME DEL DISCO 3:
$ecryptfs-unwrap-passphrase /media/usuario/943c59f4-41d2-4rtf-a27c-g65bctr1f276/home/.ecryptfs/usuario/.ecryptfs/wrapped-passphrase
Passphrase:
e25c829b60e65e63a1ec2b9581ae4d4a
$ecryptfs-add-passphrase --fnek
Passphrase:
Inserted auth tok with sig [b6829c7b365a3b16] into the user session keyring
Inserted auth tok with sig [b906f5e58bfbce18] into the user session keyring

3
Linux/renombrar multiples ficheros.txt Normal file
View File

@ -0,0 +1,3 @@
#Renombrarmos todos los .conf por .txt_bak
for f in *.txt; do mv -- "$f" "${f%.conf}.txt_bak"; done

28
Linux/rsync Exit Codes.txt Normal file
View File

@ -0,0 +1,28 @@
https://lxadm.com/Rsync_exit_codes
0 Success
1 Syntax or usage error
2 Protocol incompatibility
3 Errors selecting input/output files, dirs
4 Requested action not supported: an attempt was made to manipulate 64-bit files on a platform that cannot support them; or an option was specified that is supported by the client and not by the server.
5 Error starting client-server protocol
6 Daemon unable to append to log-file
10 Error in socket I/O
11 Error in file I/O
12 Error in rsync protocol data stream
13 Errors with program diagnostics
14 Error in IPC code
20 Received SIGUSR1 or SIGINT
21 Some error returned by waitpid()
22 Error allocating core memory buffers
23 Partial transfer due to error
24 Partial transfer due to vanished source files
25 The --max-delete limit stopped deletions
30 Timeout in data send/receive
35 Timeout waiting for daemon connection
To check rsync exit code on Linux / UNIX (or in fact, any other command), run this one just after rsync command:
echo $?
To check rsync exit code on Windows, run this one just after rsync command:
echo Exit Code is %errorlevel%

48
Linux/screen_linux.txt Normal file
View File

@ -0,0 +1,48 @@
Creando una nueva sesión de screen
$ screen -S nginxSetup -t virtualHost
Con este comando creamos una nueva sesión de screen (nginxSetup) con una nueva ventana (virtualHost). En una sesión de screen podemos crear multiples ventanas.
$ screen -t startScript
Dentro de una sesión
Estas son algunas de las combinaciones posibles para manejarse dentro de una sesión de screen.
Manejo de las ventanas
Con estas combinación de teclas nos podemos desplazar por las ventanas creadas con screen -t.
Ctrl-a ? Ayuda y sumario de funciones
Ctrl-a c Crear una nueva ventana (sin nombre).
Ctrl-a Ctrl-n Cambiar a la Siguiente o Anterior terminal
Ctrl-a Ctrl-N Cambiar a la Siguiente o Anterior terminal N [0-9]
Ctrl-a ” Lista navegable de terminales en funcionamiento
Ctrl-a a Limpiar un Ctrl-a pulsado por error
Ctrl-a Ctrl-d Desconectar y dejar la sesión en funcionamiento
Ctrl-a x Bloquear todas las terminales con una clave
Dividir screen
Ctrl-a S Divide horizontalmente
Ctrl-a tab Salta a la siguiente zona
Ctrl-a X Cerrar la zona actual
Ctrl-a Q Cerrar todas las zonas excepto la actual
Salir de screen
Ctrl-a d Dettach. Sale de la sesión pero la deja en segundo plano
junto a todas sus ventanas.
exit Cierra la ventana actual. Cerrando todas las ventanas
se cierra la sesión de screen.
Opciones de copiado
Ctrl-a + [ Entrar en modo copia/scroll.
Enter Comenzar la selección de texto / Finalizar la selección
de texto, copiar y salir modo copia/scroll.
Cursor Desplazamiento del cursor selecciona el texto a
copiar (si estamos en modo copia/scroll).
ESC Salir del modo copia/scroll sin copiar nada.
Ctrl-a + ] Pegar el texto copiado.

12
Linux/sed - modificar, añadir y borrar lineas.txt Normal file
View File

@ -0,0 +1,12 @@
MODIFICAR:
# cambia 'Microsoft Windows' por 'GNU Linux' (el parámetro -i los hace permanentes)
sed 's/Microsoft Windows/GNU Linux/g' -i fichero.txt
AÑADIR:
# añade la linea "alejandro ALL=(ALL:ALL) ALL" despues de la linea que pone "User privilege" al fichero sudoers
sed -i '/User privilege/a eugenio ALL=(ALL:ALL) ALL' sudoers
ELIMINAR:
# elimina la linea que contenga "alejandro" del fichero sudoers
sed -i '/alejandro/d' sudoers

97
Linux/sed en Linux y UNIX con ejemplos.txt Normal file
View File

@ -0,0 +1,97 @@
Uso del comando SED en Linux y UNIX con ejemplos
Hablamos del popular comando SED, básico en el día a día en sistemas UNIX y GNU/Linux. Su nombre es un acrónimo del inglés de editor de secuencias (“Stream Editor”) y nos permite realizar muchas funciones en archivos como, por ejemplo: buscar, buscar y reemplazar, insertar o eliminar.
Aún así el uso más común de SED en UNIX y GNU/Linux es para sustituir o para buscar y reemplazar. Al utilizar SED, podemos editar archivos, incluso sin abrirlos, de manera individual o masiva. Dicho sea, que esta forma, es mucho más rápida para encontrar y reemplazar algo en un archivo de manera manual.
SED es un potente editor de flujo de texto. Podemos hacer insertar, borrar, buscar y reemplazar.
Dicho comando admite expresiones regulares que le permiten realizar una comparación de patronos complejos.
Uso del comando Sed en Linux
---------------------------------------
Lo cierto es que tiene una curva media de aprendizaje, sobre todo en lo que respecta al uso combinado con las expresiones regulares.
Su sintaxis es la siguiente:
sed OPCIONES... [SCRIPT] [FICHERO...]
Para ver su funcionamiento, vamos a considerar el siguiente texto:
“La empresa tiene todos sus sistemas operativos con Microsoft Windows,
en sus últimas versiones. Con Microsoft Windows conseguimos alcanzar nuestros objetivos.
Microsoft Windows es una empresa que genera confianza.
Reemplazar o sustituir un string
--------------------------------------
El comando Sed se usa principalmente para reemplazar el texto en un archivo. El siguiente comando simple sed reemplaza la palabra “Microsoft Windows” por “GNU Linux” en el archivo.
$sed 's/Microsoft Windows/GNU Linux/' fichero.txt
De esta manera el resultado es el siguiente:
“La empresa tiene todos sus sistemas operativos con GNU Linux,
en sus últimas versiones. Con Microsoft Windows conseguimos alcanzar nuestros objetivos.
Microsoft Windows es una empresa que genera confianza.”
Como se puede observar solo ha hecho el cambio en la primera frase. Antes de continuar, veamos que hemos hecho. Con el parámetro “s” especificamos la operación de sustitución. Los “/” son delimitadores. “Microsoft Windows” es el patrón de búsqueda y el “GNU Linux” es la cadena de reemplazo.
De manera predeterminada, el comando sed reemplaza la primera aparición del patrón en cada línea y no reemplazará la segunda y consecutivas.
NOTA IMPORTANTE: Si queremos que los cambios sean permanentes en el fichero, debemos utilizar el parámetro “-i“, justo después del comando SED.
Reemplazar un número dado de apariciones de un string
-------------------------------------------------------------
Para reemplazar un número dado de apariciones de un string, siempre siguiendo el orden de aparición, debemos usar los indicadores numéricos, para así reemplazar la primera, segunda, etc, apariciones de un patrón en una línea.
Ahora vamos a sustituir la segunda aparición:
sed 's/Microsoft Windows/GNU Linux/2' fichero.txt
Quedando así:
"La empresa tiene todos sus sistemas operativos con Microsoft Windows,
en sus últimas versiones. Con GNU Linux conseguimos alcanzar nuestros objetivos.
Microsoft Windows es una empresa que genera confianza."
Reemplazar todas las apariciones de un string en un texto
-----------------------------------------------------------------
Para reemplazar todas las apariciones de un patrón en un texto: El indicador “/g” (reemplazo global) especifica el comando sed para reemplazar todas las apariciones de la cadena en la línea.
sed 's/Microsoft Windows/GNU Linux/g' fichero.txt
Quedando como sigue:
“La empresa tiene todos sus sistemas operativos con GNU Linux,
en sus últimas versiones. Con GNU Linux conseguimos alcanzar nuestros objetivos.
GNU Linux es una empresa que genera confianza.”
Reemplazo de la ocurrencia nth a todas las apariciones en una línea.
--------------------------------------------------------------------------------
Usamos la combinación de “/1“,” /2“, etc. y “/g” para reemplazar todos los patrones en el texto. El siguiente comando sed reemplaza la tercera, cuarta, quinta … palabra “Microsoft Windows” por “GNU Linux” en una línea.
Como sigue:
sed 's/Microsoft Windows/GNU Linux/3g' fichero.txt
Poner entre paréntesis el primer carácter de cada palabra
----------------------------------------------------------------
Este ejemplo muestra el primer carácter de cada palabra en paréntesis:
echo "Bienvenidos al Mundo de los Bits y los Bytes" | sed 's/\(\b[A-Z]\)/\(\1\)/g'
Con el resultado:
(B)ienvenidos (A)l (M)undo de los (B)its y los (B)ytes
Reemplazar un string en un número de línea específico.
------------------------------------------------------------------
Podemos restringir el comando sed para reemplazar la cadena en un número de línea específico.
Por ejemplo:
sed '3 s/Microsoft Windows/GNU Linux/' fichero.txt
Duplicar la línea reemplazada con el indicador “/p”
-----------------------------------------------------------
El indicador de impresión “/p” imprime la línea reemplazada dos veces en el terminal. Si una línea no tiene el patrón de búsqueda y no se reemplaza, entonces “/p” imprime esa línea solo una vez.
$sed 's/Microsoft Windows/GNU Linux/p' fichero.txt
Reemplazar un valor entre un rango de líneas.
----------------------------------------------------
Podemos realizar un reemplazo de valores entre un rango de líneas de un fichero dado.
Por ejemplo:
$sed '1,3 s/Microsoft Windows/GNU Linux/' fichero.txt
Borrar líneas de un fichero
------------------------------------
El comando SED se pueda utilizar para eliminar una o varias líneas de un fichero. De esta manera SED nos permite eliminar líneas de un fichero sin tener que acceder a este.
Por ejemplo, para borrar una línea en cuestión:
Uso:
$ sed 'nd' fichero.txt
Ejemplo:
$ sed '5d' fichero.txt
O bien borrar la última línea:
$ sed '$d' fichero.txt
Entre un rango de líneas:
sed '3,6d' fichero.txt
Conclusión
Hemos visto con unos cuantos ejemplos las ventajas de trabajar con SED para modificar ficheros en nuestro sistema operativo. Una muestra más de la increíble navaja suiza que es la terminal de comandos en GNU/Linux
Fuentes consultadas:
Geeksforgeeks.org – Sed Command in Linux (https://www.geeksforgeeks.org/sed-command-in-linux-unix-with-examples/)

Some files were not shown because too many files have changed in this diff Show More